@moltbankhq/openclaw 0.1.17 → 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
 
@@ -44,16 +50,15 @@ After installing, run:
 moltbank setup
 ```
 
-By default, `moltbank setup` issues the browser activation code, starts background finalization, and returns without hanging on approval. Host setup also skips automatic gateway restarts by default so the active chat session is not interrupted. Use `moltbank setup --blocking` or `moltbank setup-blocking` when you want the command to wait for approval and finish readiness verification in the foreground.
+The CLI will guide you through linking your MoltBank account via browser-based OAuth. Once approved, setup verifies a real authenticated balance read before reporting success.
 
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
-| `moltbank setup` | Start setup in nonblocking mode and return after issuing activation steps |
-| `moltbank setup --blocking` | Run setup and wait for approval in the foreground |
+| `moltbank setup` | Run full setup and verify readiness |
 | `moltbank setup --verbose` | Run setup with detailed logs |
-| `moltbank setup-blocking` | Run setup and wait for approval |
+| `moltbank setup-blocking` | Alias for setup |
 | `moltbank status` | Check current auth state |
 | `moltbank auth-status` | Alias for `moltbank status` |
 | `moltbank sandbox-setup` | Reconfigure sandbox Docker settings |
@@ -66,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
@@ -75,10 +98,8 @@ 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`) |
-| `MOLTBANK_SETUP_RESTART_GATEWAY` | `true` or `false` (default: `false`) |
 
 ## Capabilities
 

package/cli.ts

@@ -5,7 +5,6 @@ import {
   createSetupCommandLogger,
   ensureMcporterConfig,
   getAppBaseUrl,
-  getSetupAuthWaitMode,
   getSetupGatewayRestartEnabled,
   getSkillDir,
   injectSandboxEnv,
@@ -17,7 +16,6 @@ import {
 type CliConfig = {
   appBaseUrl?: string;
   skillName?: string;
-  workspacePath?: string;
 };
 
 type ParsedArgs = {
@@ -37,7 +35,7 @@ Usage:
 
 Commands:
   setup             Run MoltBank setup
-  setup-blocking    Run setup and wait for approval
+  setup-blocking    Alias for setup
   status            Show current MoltBank auth state
   auth-status       Alias for status
   sandbox-setup     Reconfigure sandbox Docker settings in openclaw.json
@@ -47,18 +45,15 @@ Commands:
 Options:
   --app-base-url <url>  Override MoltBank deployment URL
   --skill-name <name>   Override skill folder name
-  --workspace <path>    Override OpenClaw workspace path
-  --blocking            Wait for browser approval before setup exits
+  --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 (default)
+  --no-restart-gateway  Skip gateway restart after successful host setup
   --verbose             Show detailed setup logs
   -h, --help            Show help
   -v, --version         Show package version
 
 Examples:
   moltbank setup
-  moltbank setup --workspace ~/.openclaw/workspace
-  moltbank setup --blocking
   moltbank setup --verbose
   moltbank status
   moltbank register --app-base-url https://app.moltbank.bot
@@ -142,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}`);
     }
@@ -180,11 +160,10 @@ async function runCommand(parsed: ParsedArgs): Promise<void> {
 
   switch (parsed.command) {
     case 'setup': {
-      const restartGatewayOnSuccess = parsed.restartGateway ?? getSetupGatewayRestartEnabled(false);
+      const restartGatewayOnSuccess = parsed.restartGateway ?? getSetupGatewayRestartEnabled(process.platform === 'win32');
       const logger = createSetupCommandLogger({ verbose: parsed.verbose, statusCommand: 'moltbank status' });
-      const authWaitMode = parsed.blocking ? 'blocking' : getSetupAuthWaitMode('nonblocking');
       try {
-        await runSetup(cfg, logger, { authWaitMode, restartGatewayOnSuccess });
+        await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
       } finally {
         logger.finish();
       }
@@ -192,7 +171,7 @@ async function runCommand(parsed: ParsedArgs): Promise<void> {
     }
 
     case 'setup-blocking': {
-      const restartGatewayOnSuccess = parsed.restartGateway ?? getSetupGatewayRestartEnabled(false);
+      const restartGatewayOnSuccess = parsed.restartGateway ?? getSetupGatewayRestartEnabled(process.platform === 'win32');
       const logger = createSetupCommandLogger({ verbose: parsed.verbose, statusCommand: 'moltbank status' });
       try {
         await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });

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.17",
-    "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",