@moltbankhq/openclaw 0.1.2 → 0.1.4

package/README.md

@@ -1,20 +1,30 @@
 # @moltbankhq/openclaw
 
-OpenClaw plugin 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
 
 ```bash
-openclaw plugins install @moltbankhq/openclaw
+npm install -g @moltbankhq/openclaw
 ```
 
-Direct `npm install` can be useful to acquire the package, but by itself it does not complete OpenClaw plugin registration or setup.
+You can also run it without a global install:
+
+```bash
+npx @moltbankhq/openclaw setup
+```
+
+OpenClaw plugin mode still exists in this pass for compatibility:
+
+```bash
+openclaw plugins install @moltbankhq/openclaw
+```
 
 ## What it does
 
-This plugin connects your OpenClaw agent to MoltBank's stablecoin treasury infrastructure. On install, it:
+This package connects your OpenClaw agent to MoltBank's stablecoin treasury infrastructure. During setup, it:
 
-- Downloads and configures the MoltBank skill (SKILL.md + scripts)
+- Downloads and configures the MoltBank skill (`skill.md` + scripts)
 - Installs and registers [mcporter](https://www.npmjs.com/package/mcporter) for MCP server connectivity
 - Handles OAuth device-code authentication to link your agent to your MoltBank account
 - Configures sandbox (Docker) or host mode automatically based on your OpenClaw setup
@@ -27,24 +37,33 @@ Once set up, your agent can manage treasury operations, set per-agent spending l
 After installing, run:
 
 ```bash
-openclaw moltbank setup
+moltbank setup
 ```
 
-The plugin will guide you through linking your MoltBank account via browser-based OAuth. Once approved, setup finalizes automatically.
+The CLI will guide you through linking your MoltBank account via browser-based OAuth. Once approved, setup finalizes automatically.
 
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
-| `openclaw moltbank setup` | Run full setup (nonblocking auth) |
-| `openclaw moltbank setup-blocking` | Setup and wait for OAuth approval |
-| `openclaw moltbank auth-status` | Check current auth state |
-| `openclaw moltbank sandbox-setup` | Reconfigure sandbox Docker settings |
-| `openclaw moltbank inject-key` | Re-inject env vars from credentials |
-| `openclaw moltbank register` | Re-register mcporter MCP server |
+| `moltbank setup` | Run full setup (nonblocking auth by default) |
+| `moltbank setup --blocking` | Run setup and wait for OAuth approval |
+| `moltbank setup-blocking` | Run setup and wait for OAuth approval |
+| `moltbank auth-status` | Check current auth state |
+| `moltbank sandbox-setup` | Reconfigure sandbox Docker settings |
+| `moltbank inject-key` | Re-inject env vars from credentials |
+| `moltbank register` | Re-register mcporter MCP server |
 
 ## Configuration
 
+CLI flags:
+
+```bash
+moltbank setup --app-base-url https://app.moltbank.bot --skill-name MoltBank
+```
+
+Plugin mode can still read optional config from your `openclaw.json`:
+
 Optional config in your `openclaw.json`:
 
 ```json

package/bin/moltbank.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'child_process';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const binDir = dirname(fileURLToPath(import.meta.url));
+const cliPath = resolve(binDir, '../cli.ts');
+const result = spawnSync(process.execPath, ['--import', 'tsx/esm', cliPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env
+});
+
+if (result.error) {
+  console.error(`[moltbank] failed to start CLI: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/cli.ts

@@ -0,0 +1,203 @@
+import { readFileSync } from 'fs';
+import process from 'process';
+import {
+  configureSandbox,
+  ensureMcporterConfig,
+  getAppBaseUrl,
+  getSetupAuthWaitMode,
+  getSkillDir,
+  injectSandboxEnv,
+  printAuthStatus,
+  recreateSandboxAndRestart,
+  runSetup
+} from './index.ts';
+
+type CliConfig = {
+  appBaseUrl?: string;
+  skillName?: string;
+};
+
+type ParsedArgs = {
+  command?: string;
+  config: CliConfig;
+  help: boolean;
+  version: boolean;
+  blocking: boolean;
+};
+
+const HELP_TEXT = `MoltBank CLI
+
+Usage:
+  moltbank <command> [options]
+
+Commands:
+  setup             Run MoltBank setup (nonblocking auth by default)
+  setup-blocking    Run MoltBank setup and wait for OAuth approval
+  auth-status       Show current MoltBank auth state
+  sandbox-setup     Reconfigure sandbox Docker settings in openclaw.json
+  inject-key        Re-inject sandbox env vars from credentials.json
+  register          Re-register mcporter MCP config
+
+Options:
+  --app-base-url <url>  Override MoltBank deployment URL
+  --skill-name <name>   Override skill folder name
+  --blocking            Alias for blocking auth mode with setup
+  -h, --help            Show help
+  -v, --version         Show package version
+
+Examples:
+  moltbank setup
+  moltbank setup --blocking
+  moltbank auth-status
+  moltbank register --app-base-url https://app.moltbank.bot
+`;
+
+function readVersion(): string {
+  const packageUrl = new URL('./package.json', import.meta.url);
+  const packageJson = JSON.parse(readFileSync(packageUrl, 'utf8')) as { version?: string };
+  return packageJson.version ?? '0.0.0';
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const config: CliConfig = {};
+  const positional: string[] = [];
+  let help = false;
+  let version = false;
+  let blocking = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '-h' || arg === '--help') {
+      help = true;
+      continue;
+    }
+
+    if (arg === '-v' || arg === '--version') {
+      version = true;
+      continue;
+    }
+
+    if (arg === '--blocking') {
+      blocking = true;
+      continue;
+    }
+
+    if (arg === '--app-base-url') {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new Error('missing value for --app-base-url');
+      }
+      config.appBaseUrl = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--app-base-url=')) {
+      config.appBaseUrl = arg.slice('--app-base-url='.length);
+      continue;
+    }
+
+    if (arg === '--skill-name') {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new Error('missing value for --skill-name');
+      }
+      config.skillName = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--skill-name=')) {
+      config.skillName = arg.slice('--skill-name='.length);
+      continue;
+    }
+
+    if (arg.startsWith('-')) {
+      throw new Error(`unknown option: ${arg}`);
+    }
+
+    positional.push(arg);
+  }
+
+  return {
+    command: positional[0],
+    config,
+    help,
+    version,
+    blocking
+  };
+}
+
+async function runCommand(parsed: ParsedArgs): Promise<void> {
+  const cfg = parsed.config;
+  const logger = { logger: console };
+
+  switch (parsed.command) {
+    case 'setup': {
+      const authWaitMode = parsed.blocking ? 'blocking' : getSetupAuthWaitMode('nonblocking');
+      await runSetup(cfg, logger, { authWaitMode });
+      return;
+    }
+
+    case 'setup-blocking': {
+      await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+      return;
+    }
+
+    case 'auth-status': {
+      printAuthStatus(getSkillDir(cfg), getAppBaseUrl(cfg), logger);
+      return;
+    }
+
+    case 'sandbox-setup': {
+      const changed = configureSandbox(logger);
+      if (changed) {
+        recreateSandboxAndRestart(logger);
+      } else {
+        console.log('[moltbank] No sandbox docker changes — not scheduling teardown');
+      }
+      return;
+    }
+
+    case 'inject-key': {
+      const changed = injectSandboxEnv(getSkillDir(cfg), logger);
+      if (changed) {
+        recreateSandboxAndRestart(logger);
+      } else {
+        console.log('[moltbank] No env changes — not scheduling teardown');
+      }
+      return;
+    }
+
+    case 'register': {
+      ensureMcporterConfig(getSkillDir(cfg), getAppBaseUrl(cfg), logger);
+      return;
+    }
+
+    default:
+      throw new Error(`unknown command: ${parsed.command}`);
+  }
+}
+
+async function main(): Promise<void> {
+  const parsed = parseArgs(process.argv.slice(2));
+
+  if (parsed.version) {
+    console.log(readVersion());
+    return;
+  }
+
+  if (parsed.help || !parsed.command) {
+    console.log(HELP_TEXT);
+    return;
+  }
+
+  await runCommand(parsed);
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[moltbank] ${message}`);
+  process.exit(1);
+});

package/index.ts

@@ -7,7 +7,7 @@ const IS_WIN = process.platform === 'win32';
 type OpenclawConfig = Record<string, unknown>;
 type ParsedJsonObject = Record<string, unknown>;
 
-interface MoltbankPluginConfig {
+export interface MoltbankPluginConfig {
   skillName?: string;
   appBaseUrl?: string;
 }
@@ -62,7 +62,7 @@ interface PluginApi extends LoggerApi {
   registerCli(handler: (args: { program: CliCommandLike }) => void, options: { commands: string[] }): void;
 }
 
-type AuthWaitMode = 'blocking' | 'nonblocking';
+export type AuthWaitMode = 'blocking' | 'nonblocking';
 const oauthPollers = new Map<string, ReturnType<typeof spawn>>();
 const backgroundFinalizers = new Map<string, ReturnType<typeof spawn>>();
 
@@ -86,7 +86,7 @@ function asStringRecord(value: unknown): Record<string, string> {
   return out;
 }
 
-function getSetupAuthWaitMode(defaultMode: AuthWaitMode): AuthWaitMode {
+export function getSetupAuthWaitMode(defaultMode: AuthWaitMode): AuthWaitMode {
   const raw = asString(process.env.MOLTBANK_SETUP_AUTH_WAIT_MODE).trim().toLowerCase();
   if (raw === 'blocking' || raw === 'wait') return 'blocking';
   if (raw === 'nonblocking' || raw === 'nowait') return 'nonblocking';
@@ -133,14 +133,19 @@ function getWorkspace(): string {
   return process.env.OPENCLAW_WORKSPACE || join(homedir(), '.openclaw', 'workspace');
 }
 
-function getSkillName(cfg: MoltbankPluginConfig): string {
+export function getSkillName(cfg: MoltbankPluginConfig): string {
   return cfg?.skillName || process.env.MOLTBANK_SKILL_NAME || 'MoltBank';
 }
 
-function getAppBaseUrl(cfg: MoltbankPluginConfig): string {
+export function getAppBaseUrl(cfg: MoltbankPluginConfig): string {
   return (cfg?.appBaseUrl || process.env.APP_BASE_URL || 'https://app.moltbank.bot').trim();
 }
 
+export function getSkillBundleBaseUrl(cfg: MoltbankPluginConfig): string {
+  const base = getAppBaseUrl(cfg).replace(/\/$/, '');
+  return base.endsWith('/skill') ? base : `${base}/skill`;
+}
+
 function isSandboxEnabled(): boolean {
   try {
     const configPath = join(homedir(), '.openclaw', 'openclaw.json');
@@ -152,7 +157,7 @@ function isSandboxEnabled(): boolean {
   }
 }
 
-function getSkillDir(cfg: MoltbankPluginConfig): string {
+export function getSkillDir(cfg: MoltbankPluginConfig): string {
   const skillName = getSkillName(cfg);
   return join(getWorkspace(), 'skills', skillName);
 }
@@ -850,7 +855,7 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
   return true;
 }
 
-function printAuthStatus(skillDir: string, appBaseUrl: string, api: LoggerApi): void {
+export function printAuthStatus(skillDir: string, appBaseUrl: string, api: LoggerApi): void {
   const now = Math.floor(Date.now() / 1000);
   const existing = parseActiveTokenFromCredentials();
   const pending = readPendingOauthCode(skillDir);
@@ -878,11 +883,11 @@ function printAuthStatus(skillDir: string, appBaseUrl: string, api: LoggerApi):
   api.logger.info(`[moltbank]   background poll: ${pollerRunning ? 'running' : 'idle'}`);
   api.logger.info(`[moltbank]   background finalize: ${finalizerRunning ? 'running' : 'idle'}`);
   if (!existing.ok && !pending) {
-    api.logger.info('[moltbank]   hint: run `openclaw moltbank setup` to start onboarding');
+    api.logger.info('[moltbank]   hint: run `moltbank setup` to start onboarding');
   }
 }
 
-function ensureMcporterConfig(skillDir: string, appBaseUrl: string, api: LoggerApi) {
+export function ensureMcporterConfig(skillDir: string, appBaseUrl: string, api: LoggerApi) {
   const cfgPath = join(skillDir, 'assets', 'mcporter.json');
   mkdirSync(join(skillDir, 'assets'), { recursive: true });
 
@@ -937,7 +942,7 @@ function ensureMcporterConfig(skillDir: string, appBaseUrl: string, api: LoggerA
 
 // ─── sandbox env vars ────────────────────────────────────────────────────────
 
-function injectSandboxEnv(skillDir: string, api: LoggerApi): boolean {
+export function injectSandboxEnv(skillDir: string, api: LoggerApi): boolean {
   const credsPath = getCredentialsPath();
 
   if (!existsSync(credsPath)) {
@@ -1035,7 +1040,7 @@ function injectSandboxEnv(skillDir: string, api: LoggerApi): boolean {
 
 // ─── sandbox docker config ────────────────────────────────────────────────────
 
-function configureSandbox(api: LoggerApi): boolean {
+export function configureSandbox(api: LoggerApi): boolean {
   const SETUP_CMD =
     'echo \'APT::Sandbox::User "root";\' > /etc/apt/apt.conf.d/99sandbox && ' +
     'apt-get update -qq && ' +
@@ -1107,7 +1112,7 @@ function configureSandbox(api: LoggerApi): boolean {
 
 // ─── sandbox recreate + gateway restart ──────────────────────────────────────
 
-function recreateSandboxAndRestart(api: LoggerApi) {
+export function recreateSandboxAndRestart(api: LoggerApi) {
   api.logger.info('[moltbank] recreating sandbox containers...');
   api.logger.info('[moltbank] ⏳ waiting 8s before recreate (hot container protection)...');
   setTimeout(() => {
@@ -1142,16 +1147,21 @@ function recreateSandboxAndRestart(api: LoggerApi) {
 
 // ─── main setup ───────────────────────────────────────────────────────────────
 
-async function runSetup(cfg: MoltbankPluginConfig, api: LoggerApi, options: { authWaitMode?: AuthWaitMode } = {}) {
+export async function runSetup(
+  cfg: MoltbankPluginConfig,
+  api: LoggerApi,
+  options: { authWaitMode?: AuthWaitMode } = {}
+) {
   let hostReady = false;
   const appBaseUrl = getAppBaseUrl(cfg);
+  const skillBundleBaseUrl = getSkillBundleBaseUrl(cfg);
   const skillName = getSkillName(cfg);
   const sandbox = isSandboxEnabled();
   const skillDir = getSkillDir(cfg);
   const waitForAuth = (options.authWaitMode ?? 'blocking') === 'blocking';
 
   api.logger.info(`[moltbank] ══════════════════════════════════════`);
-  api.logger.info(`[moltbank] MoltBank plugin setup starting`);
+  api.logger.info(`[moltbank] MoltBank setup starting`);
   api.logger.info(`[moltbank] mode:      ${sandbox ? 'sandbox (Docker)' : 'host (direct)'}`);
   api.logger.info(`[moltbank] skill dir: ${skillDir}`);
   api.logger.info(`[moltbank] base url:  ${appBaseUrl}`);
@@ -1166,7 +1176,7 @@ async function runSetup(cfg: MoltbankPluginConfig, api: LoggerApi, options: { au
     ensureMcporter(api);
 
     api.logger.info('[moltbank] [sandbox 1/10] installing skill files...');
-    const skillInstalled = ensureSkillInstalled(skillDir, appBaseUrl, skillName, api, 'sandbox');
+    const skillInstalled = ensureSkillInstalled(skillDir, skillBundleBaseUrl, skillName, api, 'sandbox');
     if (!skillInstalled) {
       api.logger.warn('[moltbank] skill install failed — aborting sandbox setup');
       return;
@@ -1223,7 +1233,7 @@ async function runSetup(cfg: MoltbankPluginConfig, api: LoggerApi, options: { au
     ensureMcporter(api);
 
     api.logger.info('[moltbank] [host 2/8] installing skill files...');
-    const installed = ensureSkillInstalled(skillDir, appBaseUrl, skillName, api, 'host');
+    const installed = ensureSkillInstalled(skillDir, skillBundleBaseUrl, skillName, api, 'host');
     if (!installed) {
       api.logger.warn('[moltbank] host setup aborted: skill install failed. Verify install.sh/base URL and retry.');
       return;

package/package.json

@@ -1,8 +1,11 @@
 {
     "name": "@moltbankhq/openclaw",
-    "version": "0.1.2",
-    "description": "MoltBank stablecoin treasury OpenClaw plugin",
+    "version": "0.1.4",
+    "description": "MoltBank stablecoin treasury CLI and OpenClaw plugin",
     "main": "index.ts",
+    "bin": {
+        "moltbank": "./bin/moltbank.mjs"
+    },
     "openclaw": {
         "extensions": [
             "./index.ts"
@@ -12,6 +15,9 @@
     "author": "",
     "license": "ISC",
     "type": "module",
+    "dependencies": {
+        "tsx": "^4.20.6"
+    },
     "devDependencies": {
         "@types/node": "^25.5.0"
     }