@moltbankhq/openclaw 0.1.16 → 0.1.18

package/README.md

@@ -1,6 +1,6 @@
 # @moltbankhq/openclaw
 
-Standalone CLI for [MoltBank](https://moltbank.bot) — stablecoin treasury controls, approvals, and audit trails for agent fleets.
+Standalone CLI and optional OpenClaw plugin for [MoltBank](https://moltbank.bot) — stablecoin treasury controls, approvals, and audit trails for agent fleets.
 
 ## Install
 
@@ -22,6 +22,12 @@ Or from a local install:
 npm exec --package @moltbankhq/openclaw -- moltbank setup
 ```
 
+OpenClaw plugin mode still exists in this pass for compatibility:
+
+```bash
+openclaw plugins install @moltbankhq/openclaw
+```
+
 ## What it does
 
 This package connects your OpenClaw agent to MoltBank's stablecoin treasury infrastructure. During setup, it:
@@ -34,7 +40,7 @@ This package connects your OpenClaw agent to MoltBank's stablecoin treasury infr
 
 Once set up, your agent can manage treasury operations, set per-agent spending limits, handle x402 payments, and interact with MoltBank's MCP server — all within OpenClaw.
 
-The standalone `moltbank` CLI is the supported path for install, setup, auth status, and repair flows. Actual treasury operations should run through the installed skill wrapper scripts inside the skill directory.
+The standalone `moltbank` CLI is for install, setup, auth status, and repair flows. Actual treasury operations should run through the installed skill wrapper scripts inside the skill directory.
 
 ## Setup
 
@@ -65,7 +71,25 @@ CLI flags:
 
 ```bash
 moltbank setup --app-base-url https://app.moltbank.bot --skill-name MoltBank
-moltbank setup --workspace ~/.openclaw/workspace
+```
+
+Plugin mode can still read optional config from your `openclaw.json`:
+
+Optional config in your `openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "moltbank": {
+        "config": {
+          "appBaseUrl": "https://app.moltbank.bot",
+          "skillName": "MoltBank"
+        }
+      }
+    }
+  }
+}
 ```
 
 ## Environment Variables
@@ -74,7 +98,6 @@ moltbank setup --workspace ~/.openclaw/workspace
 |----------|-------------|
 | `APP_BASE_URL` | MoltBank deployment URL (default: `https://app.moltbank.bot`) |
 | `MOLTBANK_SKILL_NAME` | Override skill folder name (default: `MoltBank`) |
-| `OPENCLAW_WORKSPACE` | Override OpenClaw workspace path (default: `~/.openclaw/workspace`) |
 | `MOLTBANK_CREDENTIALS_PATH` | Custom credentials file path |
 | `MOLTBANK_SETUP_AUTH_WAIT_MODE` | `blocking` or `nonblocking` (default: `nonblocking`) |
 

package/cli.ts

@@ -16,7 +16,6 @@ import {
 type CliConfig = {
   appBaseUrl?: string;
   skillName?: string;
-  workspacePath?: string;
 };
 
 type ParsedArgs = {
@@ -46,7 +45,6 @@ Commands:
 Options:
   --app-base-url <url>  Override MoltBank deployment URL
   --skill-name <name>   Override skill folder name
-  --workspace <path>    Override OpenClaw workspace path
   --blocking            Compatibility flag; setup already waits for approval
   --restart-gateway     Force gateway restart after successful host setup
   --no-restart-gateway  Skip gateway restart after successful host setup
@@ -56,7 +54,6 @@ Options:
 
 Examples:
   moltbank setup
-  moltbank setup --workspace ~/.openclaw/workspace
   moltbank setup --verbose
   moltbank status
   moltbank register --app-base-url https://app.moltbank.bot
@@ -140,21 +137,6 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
-    if (arg === '--workspace') {
-      const value = argv[index + 1];
-      if (!value) {
-        throw new Error('missing value for --workspace');
-      }
-      config.workspacePath = value;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith('--workspace=')) {
-      config.workspacePath = arg.slice('--workspace='.length);
-      continue;
-    }
-
     if (arg.startsWith('-')) {
       throw new Error(`unknown option: ${arg}`);
     }

package/index.ts

@@ -1,16 +1,15 @@
 import { spawn, spawnSync } from 'child_process';
 import { chmodSync, chownSync, existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, type Dirent } from 'fs';
-import { join, dirname, basename, resolve } from 'path';
+import { join, dirname, basename } from 'path';
 import { homedir, userInfo } from 'os';
 const IS_WIN = process.platform === 'win32';
 
 type OpenclawConfig = Record<string, unknown>;
 type ParsedJsonObject = Record<string, unknown>;
 
-export interface MoltbankConfig {
+export interface MoltbankPluginConfig {
   skillName?: string;
   appBaseUrl?: string;
-  workspacePath?: string;
 }
 
 interface CredentialsOrganization {
@@ -54,6 +53,36 @@ export interface SetupCommandLoggerOptions {
   statusCommand?: string;
 }
 
+interface ServiceDefinition {
+  id: string;
+  start: () => void | Promise<void>;
+  stop: () => void | Promise<void>;
+}
+
+interface CliCommandLike {
+  command(name: string): CliCommandLike;
+  createCommand(name: string): CliCommandLike;
+  description(text: string): CliCommandLike;
+  addCommand(command: CliCommandLike): CliCommandLike;
+  action(handler: () => void | Promise<void>): CliCommandLike;
+}
+
+interface PluginApiConfig {
+  plugins?: {
+    entries?: {
+      moltbank?: {
+        config?: MoltbankPluginConfig;
+      };
+    };
+  };
+}
+
+interface PluginApi extends LoggerApi {
+  config?: PluginApiConfig;
+  registerService(service: ServiceDefinition): void;
+  registerCli(handler: (args: { program: CliCommandLike }) => void, options: { commands: string[] }): void;
+}
+
 export type AuthWaitMode = 'blocking' | 'nonblocking';
 const oauthPollers = new Map<string, ReturnType<typeof spawn>>();
 const backgroundFinalizers = new Map<string, ReturnType<typeof spawn>>();
@@ -392,13 +421,9 @@ function resolveWindowsCommandPath(command: string, env: NodeJS.ProcessEnv): str
   const extensions = getWindowsCommandExtensions(env);
 
   const tryCandidates = (basePath: string): string => {
-    const lower = basePath.toLowerCase();
-    const hasKnownExtension = extensions.some((ext) => lower.endsWith(ext));
-
-    if (hasKnownExtension && existsSync(basePath)) {
-      return basePath;
-    }
+    if (existsSync(basePath)) return basePath;
 
+    const lower = basePath.toLowerCase();
     for (const ext of extensions) {
       if (lower.endsWith(ext)) continue;
       const candidate = `${basePath}${ext}`;
@@ -407,10 +432,6 @@ function resolveWindowsCommandPath(command: string, env: NodeJS.ProcessEnv): str
       }
     }
 
-    if (existsSync(basePath)) {
-      return basePath;
-    }
-
     return '';
   };
 
@@ -895,41 +916,19 @@ function lastNonEmptyLine(text: string): string {
   return lines.length ? lines[lines.length - 1] : '';
 }
 
-function normalizeWorkspacePath(rawPath: string): string {
-  const trimmed = rawPath.trim();
-  if (!trimmed) {
-    return join(homedir(), '.openclaw', 'workspace');
-  }
-
-  if (trimmed === '~') {
-    return homedir();
-  }
-
-  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
-    return resolve(join(homedir(), trimmed.slice(2)));
-  }
-
-  return resolve(trimmed);
-}
-
-export function getWorkspace(cfg?: MoltbankConfig): string {
-  return normalizeWorkspacePath(cfg?.workspacePath || process.env.OPENCLAW_WORKSPACE || join(homedir(), '.openclaw', 'workspace'));
+function getWorkspace(): string {
+  return process.env.OPENCLAW_WORKSPACE || join(homedir(), '.openclaw', 'workspace');
 }
 
-function getWorkspaceFromSkillDir(skillDir: string): string {
-  const skillsDir = dirname(skillDir);
-  return basename(skillsDir) === 'skills' ? dirname(skillsDir) : getWorkspace();
-}
-
-export function getSkillName(cfg: MoltbankConfig): string {
+export function getSkillName(cfg: MoltbankPluginConfig): string {
   return cfg?.skillName || process.env.MOLTBANK_SKILL_NAME || 'MoltBank';
 }
 
-export function getAppBaseUrl(cfg: MoltbankConfig): string {
+export function getAppBaseUrl(cfg: MoltbankPluginConfig): string {
   return (cfg?.appBaseUrl || process.env.APP_BASE_URL || 'https://app.moltbank.bot').trim();
 }
 
-export function getSkillBundleBaseUrl(cfg: MoltbankConfig): string {
+export function getSkillBundleBaseUrl(cfg: MoltbankPluginConfig): string {
   const base = getAppBaseUrl(cfg).replace(/\/$/, '');
   return base.endsWith('/skill') ? base : `${base}/skill`;
 }
@@ -945,9 +944,9 @@ function isSandboxEnabled(): boolean {
   }
 }
 
-export function getSkillDir(cfg: MoltbankConfig): string {
+export function getSkillDir(cfg: MoltbankPluginConfig): string {
   const skillName = getSkillName(cfg);
-  return join(getWorkspace(cfg), 'skills', skillName);
+  return join(getWorkspace(), 'skills', skillName);
 }
 
 function getCredentialsPath(): string {
@@ -1066,6 +1065,47 @@ function setNestedValue(obj: Record<string, unknown>, path: string[], value: unk
   current[path[path.length - 1]] = value;
 }
 
+function cleanupStaleMoltbankPluginLoadPaths(api: LoggerApi): boolean {
+  try {
+    const config = readOpenclawConfig();
+    const loadPathsPath = ['plugins', 'load', 'paths'];
+    const current = getNestedValue(config, loadPathsPath);
+    if (!Array.isArray(current)) return false;
+
+    const removed: string[] = [];
+    const next: unknown[] = [];
+
+    for (const entry of current) {
+      if (typeof entry !== 'string') {
+        next.push(entry);
+        continue;
+      }
+
+      const normalized = entry.replace(/\\/g, '/').toLowerCase();
+      const looksLikeMoltbankPath = normalized.includes('moltbank');
+      if (looksLikeMoltbankPath && !existsSync(entry)) {
+        removed.push(entry);
+        continue;
+      }
+
+      next.push(entry);
+    }
+
+    if (removed.length === 0) {
+      api.logger.info('[moltbank] ✓ no stale MoltBank plugin load paths found');
+      return false;
+    }
+
+    setNestedValue(config, loadPathsPath, next);
+    writeOpenclawConfig(config);
+    api.logger.info(`[moltbank] ✓ removed stale MoltBank plugin load path(s): ${removed.join(', ')}`);
+    return true;
+  } catch (e) {
+    api.logger.warn('[moltbank] could not clean stale MoltBank plugin load paths: ' + String(e));
+    return false;
+  }
+}
+
 // ─── mcporter ────────────────────────────────────────────────────────────────
 
 function ensureMcporter(api: LoggerApi) {
@@ -1652,12 +1692,11 @@ function startBackgroundFinalizeAfterAuth(skillDir: string, appBaseUrl: string,
   }
   if (existing) backgroundFinalizers.delete(skillDir);
 
-  const child = spawn('moltbank', ['setup-blocking'], {
+  const child = spawn('openclaw', ['moltbank', 'setup-blocking'], {
     cwd: skillDir,
     env: {
       ...process.env,
       APP_BASE_URL: appBaseUrl,
-      OPENCLAW_WORKSPACE: getWorkspaceFromSkillDir(skillDir),
       MOLTBANK_SETUP_AUTH_WAIT_MODE: 'blocking'
     },
     stdio: 'ignore', // Ignore logs so it doesn't hang the parent
@@ -1810,7 +1849,7 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
     const backgroundTimeoutSeconds = Math.max(30, expiresAt - now - 5);
     startBackgroundOauthPoll(skillDir, appBaseUrl, credsPath, deviceCode, backgroundTimeoutSeconds, api);
     api.logger.info('[moltbank] once approved in browser, setup finalization will continue automatically');
-    api.logger.info('[moltbank] optional immediate check: `moltbank status`');
+    api.logger.info('[moltbank] optional immediate check: `openclaw moltbank auth-status`');
     return false;
   }
 
@@ -2210,7 +2249,7 @@ function restartGatewayAfterHostSetup(api: LoggerApi): boolean {
 // ─── main setup ───────────────────────────────────────────────────────────────
 
 export async function runSetup(
-  cfg: MoltbankConfig,
+  cfg: MoltbankPluginConfig,
   api: LoggerApi,
   options: { authWaitMode?: AuthWaitMode; restartGatewayOnSuccess?: boolean } = {}
 ) {
@@ -2229,6 +2268,9 @@ export async function runSetup(
   api.logger.info(`[moltbank] skill dir: ${skillDir}`);
   api.logger.info(`[moltbank] base url:  ${appBaseUrl}`);
   api.logger.info(`[moltbank] ══════════════════════════════════════`);
+  api.logger.info('[moltbank] preflight: cleaning stale MoltBank plugin load paths...');
+  cleanupStaleMoltbankPluginLoadPaths(api);
+
   if (sandbox) {
     api.logger.info('[moltbank] configuring sandbox mode...');
 
@@ -2256,10 +2298,10 @@ export async function runSetup(
         if (pending) {
           api.logger.warn('[moltbank] sandbox auth pending — startup continues without blocking channel startup');
           api.logger.info('[moltbank] setup will finalize automatically after browser approval');
-          api.logger.info('[moltbank] optional immediate check: `moltbank status`');
+          api.logger.info('[moltbank] optional immediate check: `openclaw moltbank auth-status`');
         } else {
           api.logger.warn('[moltbank] sandbox auth setup failed before issuing a valid device code');
-          api.logger.warn('[moltbank] review the previous error and rerun `moltbank setup`');
+          api.logger.warn('[moltbank] review the previous error and rerun `openclaw moltbank setup`');
         }
         return;
       }
@@ -2315,10 +2357,10 @@ export async function runSetup(
         if (pending) {
           api.logger.warn('[moltbank] host auth pending — startup continues without blocking channel startup');
           api.logger.info('[moltbank] setup will finalize automatically after browser approval');
-          api.logger.info('[moltbank] optional immediate check: `moltbank status`');
+          api.logger.info('[moltbank] optional immediate check: `openclaw moltbank auth-status`');
         } else {
           api.logger.warn('[moltbank] host auth setup failed before issuing a valid device code');
-          api.logger.warn('[moltbank] review the previous error and rerun `moltbank setup`');
+          api.logger.warn('[moltbank] review the previous error and rerun `openclaw moltbank setup`');
         }
         return;
       }
@@ -2335,11 +2377,7 @@ export async function runSetup(
     api.logger.info('[moltbank] [host 8/8] running readiness balance check...');
     hostReady = runHostReadinessCheck(skillDir, api);
 
-    if (hostReady) {
-      api.logger.info('[moltbank] host mode — setup completed with onboarding flow');
-    } else {
-      api.logger.warn('[moltbank] host mode setup finished, but operational readiness verification failed');
-    }
+    api.logger.info('[moltbank] host mode — setup completed with onboarding flow');
 
     if (hostReady && restartGatewayOnSuccess) {
       restartGatewayAfterHostSetup(api);
@@ -2347,19 +2385,13 @@ export async function runSetup(
   }
 
   api.logger.info(`[moltbank] ══════════════════════════════════════`);
-  if (sandbox || hostReady) {
-    api.logger.info(`[moltbank] ✓ setup complete`);
-  } else {
-    api.logger.warn('[moltbank] ✗ setup incomplete');
-  }
+  api.logger.info(`[moltbank] ✓ setup complete`);
   if (sandbox) {
     api.logger.info('[moltbank] ⏳ sandbox will be recreated in ~8s — send a message to the agent after that');
   } else if (hostReady) {
     api.logger.info('[moltbank] ✓ host ready');
-  } else {
-    api.logger.warn('[moltbank] ✗ host not ready');
   }
-  api.logger.info(`[moltbank]   skill:    ${skillDir}/skill/SKILL.md`);
+  api.logger.info(`[moltbank]   skill:    ${skillDir}/SKILL.md`);
   api.logger.info(`[moltbank]   mcporter: ${skillDir}/assets/mcporter.json`);
   if (sandbox) {
     const finalConfig = readOpenclawConfig();
@@ -2401,9 +2433,118 @@ export async function runSetup(
     }
   }
   api.logger.info(`[moltbank] ══════════════════════════════════════`);
-
-  if (!sandbox && !hostReady) {
-    throw new Error('host setup incomplete: authenticated readiness verification failed');
-  }
 }
 
+// ─── plugin register ──────────────────────────────────────────────────────────
+
+export default function register(api: PluginApi) {
+  const cfg: MoltbankPluginConfig = api.config?.plugins?.entries?.moltbank?.config ?? {};
+
+  api.registerService({
+    id: 'moltbank-setup',
+    start: async () => {
+      await runSetup(cfg, api, { authWaitMode: 'nonblocking' });
+    },
+    stop: async () => {
+      stopBackgroundOauthPoll(getSkillDir(cfg));
+      stopBackgroundFinalize(getSkillDir(cfg));
+      api.logger.info('[moltbank] plugin stopped');
+    }
+  });
+
+  api.registerCli(
+    ({ program }: { program: CliCommandLike }) => {
+      program
+        .command('moltbank')
+        .description('MoltBank plugin commands')
+        .addCommand(
+          program
+            .createCommand('setup')
+            .description('Re-run MoltBank setup')
+            .action(async () => {
+              const verbose = process.argv.includes('--verbose');
+              const restartGatewayOnSuccess = getSetupGatewayRestartEnabled(IS_WIN);
+              const logger = createSetupCommandLogger({ verbose, statusCommand: 'openclaw moltbank status' });
+              try {
+                await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
+              } finally {
+                logger.finish();
+              }
+            })
+        )
+        .addCommand(
+          program
+            .createCommand('setup-blocking')
+            .description('Re-run full MoltBank setup and wait for OAuth approval')
+            .action(async () => {
+              const verbose = process.argv.includes('--verbose');
+              const restartGatewayOnSuccess = getSetupGatewayRestartEnabled(IS_WIN);
+              const logger = createSetupCommandLogger({ verbose, statusCommand: 'openclaw moltbank status' });
+              try {
+                await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
+              } finally {
+                logger.finish();
+              }
+            })
+        )
+        .addCommand(
+          program
+            .createCommand('sandbox-setup')
+            .description('Reconfigure sandbox docker in openclaw.json')
+            .action(() => {
+              const changed = configureSandbox({ logger: console });
+              if (changed) {
+                recreateSandboxAndRestart({ logger: console });
+              } else {
+                console.log('[moltbank] No sandbox docker changes — not scheduling teardown');
+              }
+            })
+        )
+        .addCommand(
+          program
+            .createCommand('inject-key')
+            .description('Re-inject sandbox env vars from credentials.json')
+            .action(() => {
+              const skillDir = getSkillDir(cfg);
+              const changed = injectSandboxEnv(skillDir, { logger: console });
+              if (changed) {
+                recreateSandboxAndRestart({ logger: console });
+              } else {
+                console.log('[moltbank] No env changes — not scheduling teardown');
+              }
+            })
+        )
+        .addCommand(
+          program
+            .createCommand('status')
+            .description('Show current MoltBank auth state')
+            .action(() => {
+              const appBaseUrl = getAppBaseUrl(cfg);
+              const skillDir = getSkillDir(cfg);
+              printAuthStatus(skillDir, appBaseUrl, { logger: console });
+            })
+        )
+        .addCommand(
+          program
+            .createCommand('auth-status')
+            .description('Show current MoltBank auth state (credentials, pending code, background poll)')
+            .action(() => {
+              const appBaseUrl = getAppBaseUrl(cfg);
+              const skillDir = getSkillDir(cfg);
+              printAuthStatus(skillDir, appBaseUrl, { logger: console });
+            })
+        )
+        .addCommand(
+          program
+            .createCommand('register')
+            .description('Re-register mcporter server')
+            .action(() => {
+              const appBaseUrl = getAppBaseUrl(cfg);
+              const skillDir = getSkillDir(cfg);
+              ensureMcporterConfig(skillDir, appBaseUrl, { logger: console });
+            })
+        );
+    },
+    { commands: ['moltbank'] }
+  );
+}

package/openclaw.plugin.json

@@ -0,0 +1,29 @@
+{
+    "id": "moltbank",
+    "name": "MoltBank",
+    "description": "MoltBank stablecoin treasury plugin for OpenClaw — installs mcporter, npm dependencies, sandbox setup, and the MoltBank skill",
+    "configSchema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+            "appBaseUrl": {
+                "type": "string",
+                "description": "MoltBank deployment URL"
+            },
+            "skillName": {
+                "type": "string",
+                "description": "Override skill folder name (default: MoltBank)"
+            }
+        }
+    },
+    "uiHints": {
+        "appBaseUrl": {
+            "label": "App Base URL",
+            "placeholder": "https://app.moltbank.bot"
+        },
+        "skillName": {
+            "label": "Skill Name",
+            "placeholder": "MoltBank"
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@moltbankhq/openclaw",
-    "version": "0.1.16",
-    "description": "MoltBank stablecoin treasury CLI and OpenClaw skill installer",
+    "version": "0.1.18",
+    "description": "MoltBank stablecoin treasury CLI and OpenClaw plugin",
     "homepage": "https://github.com/moltbankhq/openclaw-plugin#readme",
     "repository": {
         "type": "git",
@@ -24,8 +24,14 @@
         "README.md",
         "bin/",
         "cli.ts",
-        "index.ts"
+        "index.ts",
+        "openclaw.plugin.json"
     ],
+    "openclaw": {
+        "extensions": [
+            "./index.ts"
+        ]
+    },
     "keywords": [
         "moltbank",
         "openclaw",