@moltbankhq/openclaw 0.1.6 → 0.1.8

package/README.md

@@ -40,6 +40,8 @@ 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 for install, setup, auth status, and repair flows. Actual treasury operations should run through the installed skill wrapper scripts inside the skill directory.
+
 ## Setup
 
 After installing, run:
@@ -48,16 +50,17 @@ After installing, run:
 moltbank setup
 ```
 
-The CLI 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 verifies a real authenticated balance read before reporting success.
 
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
-| `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 setup` | Run full setup and verify readiness |
+| `moltbank setup --verbose` | Run setup with detailed logs |
+| `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 |
 | `moltbank inject-key` | Re-inject env vars from credentials |
 | `moltbank register` | Re-register mcporter MCP server |

package/cli.ts

@@ -2,9 +2,9 @@ import { readFileSync } from 'fs';
 import process from 'process';
 import {
   configureSandbox,
+  createSetupCommandLogger,
   ensureMcporterConfig,
   getAppBaseUrl,
-  getSetupAuthWaitMode,
   getSkillDir,
   injectSandboxEnv,
   printAuthStatus,
@@ -23,6 +23,7 @@ type ParsedArgs = {
   help: boolean;
   version: boolean;
   blocking: boolean;
+  verbose: boolean;
 };
 
 const HELP_TEXT = `MoltBank CLI
@@ -31,9 +32,10 @@ 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
+  setup             Run MoltBank setup
+  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
   inject-key        Re-inject sandbox env vars from credentials.json
   register          Re-register mcporter MCP config
@@ -41,14 +43,15 @@ Commands:
 Options:
   --app-base-url <url>  Override MoltBank deployment URL
   --skill-name <name>   Override skill folder name
-  --blocking            Alias for blocking auth mode with setup
+  --blocking            Compatibility flag; setup already waits for approval
+  --verbose             Show detailed setup logs
   -h, --help            Show help
   -v, --version         Show package version
 
 Examples:
   moltbank setup
-  moltbank setup --blocking
-  moltbank auth-status
+  moltbank setup --verbose
+  moltbank status
   moltbank register --app-base-url https://app.moltbank.bot
 `;
 
@@ -64,6 +67,7 @@ function parseArgs(argv: string[]): ParsedArgs {
   let help = false;
   let version = false;
   let blocking = false;
+  let verbose = false;
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
@@ -83,6 +87,11 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
+    if (arg === '--verbose') {
+      verbose = true;
+      continue;
+    }
+
     if (arg === '--app-base-url') {
       const value = argv[index + 1];
       if (!value) {
@@ -125,32 +134,44 @@ function parseArgs(argv: string[]): ParsedArgs {
     config,
     help,
     version,
-    blocking
+    blocking,
+    verbose
   };
 }
 
 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 });
+      const logger = createSetupCommandLogger({ verbose: parsed.verbose, statusCommand: 'moltbank status' });
+      try {
+        await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+      } finally {
+        logger.finish();
+      }
       return;
     }
 
     case 'setup-blocking': {
-      await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+      const logger = createSetupCommandLogger({ verbose: parsed.verbose, statusCommand: 'moltbank status' });
+      try {
+        await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+      } finally {
+        logger.finish();
+      }
       return;
     }
 
+    case 'status':
     case 'auth-status': {
+      const logger = { logger: console };
       printAuthStatus(getSkillDir(cfg), getAppBaseUrl(cfg), logger);
       return;
     }
 
     case 'sandbox-setup': {
+      const logger = { logger: console };
       const changed = configureSandbox(logger);
       if (changed) {
         recreateSandboxAndRestart(logger);
@@ -161,6 +182,7 @@ async function runCommand(parsed: ParsedArgs): Promise<void> {
     }
 
     case 'inject-key': {
+      const logger = { logger: console };
       const changed = injectSandboxEnv(getSkillDir(cfg), logger);
       if (changed) {
         recreateSandboxAndRestart(logger);
@@ -171,6 +193,7 @@ async function runCommand(parsed: ParsedArgs): Promise<void> {
     }
 
     case 'register': {
+      const logger = { logger: console };
       ensureMcporterConfig(getSkillDir(cfg), getAppBaseUrl(cfg), logger);
       return;
     }

package/index.ts

@@ -1,4 +1,4 @@
-import { execSync, spawn } from 'child_process';
+import { execSync, spawn, spawnSync } from 'child_process';
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
@@ -32,6 +32,11 @@ interface LoggerApi {
   logger: LoggerLike;
 }
 
+export interface SetupCommandLoggerOptions {
+  verbose?: boolean;
+  statusCommand?: string;
+}
+
 interface ServiceDefinition {
   id: string;
   start: () => void | Promise<void>;
@@ -66,6 +71,214 @@ export type AuthWaitMode = 'blocking' | 'nonblocking';
 const oauthPollers = new Map<string, ReturnType<typeof spawn>>();
 const backgroundFinalizers = new Map<string, ReturnType<typeof spawn>>();
 
+class SetupCommandLogger implements LoggerLike {
+  private readonly verbose: boolean;
+  private readonly statusCommand: string;
+  private setupLineOpen = false;
+  private authLink = '';
+  private authCode = '';
+  private authExpiryMinutes: number | null = null;
+  private authPromptPrinted = false;
+  private waitingLineOpen = false;
+  private setupCompletePrinted = false;
+
+  constructor(options: SetupCommandLoggerOptions = {}) {
+    this.verbose = Boolean(options.verbose);
+    this.statusCommand = options.statusCommand || 'moltbank status';
+  }
+
+  info(message: string): void {
+    this.handle(message, 'info');
+  }
+
+  warn(message: string): void {
+    this.handle(message, 'warn');
+  }
+
+  finish(): void {
+    if (this.setupLineOpen) {
+      this.writeRaw('done\n');
+      this.setupLineOpen = false;
+    }
+    if (this.waitingLineOpen && process.stdout.isTTY) {
+      this.writeRaw('\n');
+      this.waitingLineOpen = false;
+    }
+  }
+
+  private handle(message: string, level: 'info' | 'warn'): void {
+    if (this.verbose) {
+      this.finish();
+      this.writeLine(message, level);
+      return;
+    }
+
+    if (message === '[moltbank] MoltBank setup starting') {
+      this.startSetupLine();
+      return;
+    }
+
+    if (this.captureAuthPrompt(message)) {
+      return;
+    }
+
+    if (message === '[moltbank] waiting for approval and polling token...') {
+      this.finishSetupLine();
+      this.flushAuthPrompt();
+      this.showWaitingLine();
+      return;
+    }
+
+    const linkedOrg = this.extractLinkedOrg(message);
+    if (linkedOrg) {
+      this.finishSetupLine();
+      this.flushAuthPrompt();
+      this.resolveWaitingLine(`[moltbank] ✓ Linked to org "${linkedOrg}"`, 'info');
+      return;
+    }
+
+    if (
+      message === '[moltbank] ✗ onboarding code expired or already consumed (invalid_grant)' ||
+      message === '[moltbank] ✗ onboarding poll failed or timed out'
+    ) {
+      this.finishSetupLine();
+      this.flushAuthPrompt();
+      this.resolveWaitingLine('[moltbank] ✗ Code expired. Run `moltbank setup` to get a new code.', 'warn');
+      return;
+    }
+
+    if (
+      message === '[moltbank] host auth not ready — complete onboarding and run setup again' ||
+      message === '[moltbank] sandbox auth not ready — complete onboarding and run setup again' ||
+      message === '[moltbank] host auth pending — startup continues without blocking channel startup' ||
+      message === '[moltbank] sandbox auth pending — startup continues without blocking channel startup' ||
+      message.startsWith('[moltbank] poll detail: ')
+    ) {
+      return;
+    }
+
+    if (message === '[moltbank] ✓ setup complete') {
+      this.finishSetupLine();
+      this.clearWaitingLine();
+      if (!this.setupCompletePrinted) {
+        this.writeLine(`[moltbank] ✓ Setup complete. Run \`${this.statusCommand}\` to verify.`, 'info');
+        this.setupCompletePrinted = true;
+      }
+      return;
+    }
+
+    if (level === 'warn') {
+      this.failSetupLine();
+      this.clearWaitingLine();
+      this.writeLine(message, 'warn');
+    }
+  }
+
+  private startSetupLine(): void {
+    if (this.setupLineOpen) return;
+    this.writeRaw('[moltbank] Setting up MoltBank skill... ');
+    this.setupLineOpen = true;
+  }
+
+  private finishSetupLine(): void {
+    if (!this.setupLineOpen) return;
+    this.writeRaw('done\n');
+    this.setupLineOpen = false;
+  }
+
+  private failSetupLine(): void {
+    if (!this.setupLineOpen) return;
+    this.writeRaw('failed\n');
+    this.setupLineOpen = false;
+  }
+
+  private captureAuthPrompt(message: string): boolean {
+    const openMatch = message.match(/^\[moltbank\] 1\) Open: (.+)$/);
+    if (openMatch) {
+      this.authLink = openMatch[1];
+      return true;
+    }
+
+    const codeMatch = message.match(/^\[moltbank\] 2\) Enter code: (.+)$/);
+    if (codeMatch) {
+      this.authCode = codeMatch[1];
+      return true;
+    }
+
+    const expiryMatch = message.match(/^\[moltbank\] 3\) Code expires in ~?(\d+) min$/);
+    if (expiryMatch) {
+      this.authExpiryMinutes = Number(expiryMatch[1]);
+      return true;
+    }
+
+    return (
+      message === '[moltbank] ACTION REQUIRED: link this agent to your MoltBank account' ||
+      message === '[moltbank] 4) Optional: reply in chat "MoltBank done" for a live status check'
+    );
+  }
+
+  private flushAuthPrompt(): void {
+    if (this.authPromptPrinted || !this.authLink || !this.authCode) return;
+    this.writeLine('[moltbank]', 'info');
+    this.writeLine(`[moltbank] Link your agent → ${this.authLink}`, 'info');
+    const expirySuffix = this.authExpiryMinutes ? ` (expires in ${this.authExpiryMinutes} min)` : '';
+    this.writeLine(`[moltbank] Code: ${this.authCode}${expirySuffix}`, 'info');
+    this.writeLine('[moltbank]', 'info');
+    this.authPromptPrinted = true;
+  }
+
+  private showWaitingLine(): void {
+    if (this.waitingLineOpen) return;
+    if (process.stdout.isTTY) {
+      this.writeRaw('[moltbank] Waiting for approval...');
+      this.waitingLineOpen = true;
+      return;
+    }
+    this.writeLine('[moltbank] Waiting for approval...', 'info');
+  }
+
+  private resolveWaitingLine(message: string, level: 'info' | 'warn'): void {
+    if (this.waitingLineOpen && process.stdout.isTTY) {
+      this.writeRaw(`\r\u001b[2K${message}\n`, level);
+      this.waitingLineOpen = false;
+      return;
+    }
+    this.writeLine(message, level);
+  }
+
+  private clearWaitingLine(): void {
+    if (!this.waitingLineOpen) return;
+    if (process.stdout.isTTY) {
+      this.writeRaw('\n');
+    }
+    this.waitingLineOpen = false;
+  }
+
+  private extractLinkedOrg(message: string): string | null {
+    const match = message.match(
+      /^\[moltbank\] ✓ (?:background )?(?:onboarding completed|credentials\.json already available) \(active org: (.+)\)$/
+    );
+    return match?.[1] ?? null;
+  }
+
+  private writeLine(message: string, level: 'info' | 'warn'): void {
+    this.writeRaw(`${message}\n`, level);
+  }
+
+  private writeRaw(message: string, level: 'info' | 'warn' = 'info'): void {
+    const stream = level === 'warn' ? process.stderr : process.stdout;
+    stream.write(message);
+  }
+}
+
+export function createSetupCommandLogger(options: SetupCommandLoggerOptions = {}): LoggerApi & { finish(): void } {
+  const logger = new SetupCommandLogger(options);
+  return {
+    logger,
+    finish: () => logger.finish()
+  };
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
@@ -550,6 +763,84 @@ function readPendingOauthCode(skillDir: string): {
   }
 }
 
+function clearPendingOauthCode(skillDir: string): void {
+  const pendingPath = join(skillDir, '.oauth_device_code.json');
+  try {
+    if (existsSync(pendingPath)) unlinkSync(pendingPath);
+  } catch {
+    // ignore
+  }
+}
+
+function runProcess(
+  command: string,
+  args: string[],
+  opts: { cwd?: string; silent?: boolean; env?: Record<string, string | undefined> } = {}
+) {
+  try {
+    const mergedEnv: NodeJS.ProcessEnv = { ...process.env, ...(opts.env ?? {}) };
+    const result = spawnSync(command, args, {
+      cwd: opts.cwd,
+      env: mergedEnv,
+      encoding: 'utf8',
+      stdio: opts.silent ? 'pipe' : 'inherit'
+    });
+    return {
+      ok: result.status === 0,
+      stdout: (result.stdout ?? '').toString().trim(),
+      stderr: (result.stderr ?? '').toString().trim()
+    };
+  } catch (e: unknown) {
+    return {
+      ok: false,
+      stdout: '',
+      stderr: getExecErrorMessage(e)
+    };
+  }
+}
+
+function runMoltbankWrapper(skillDir: string, args: string[]) {
+  if (IS_WIN) {
+    const ps1Path = join(skillDir, 'scripts', 'moltbank.ps1');
+    return runProcess('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', ps1Path, ...args], {
+      cwd: skillDir,
+      silent: true
+    });
+  }
+
+  return runProcess(join(skillDir, 'scripts', 'moltbank.sh'), args, {
+    cwd: skillDir,
+    silent: true
+  });
+}
+
+function verifyMoltbankOperationalReadiness(skillDir: string, api: LoggerApi): boolean {
+  const existing = parseActiveTokenFromCredentials();
+  if (!existing.ok || !existing.activeOrg) {
+    api.logger.warn('[moltbank] ✗ setup incomplete: authenticated org could not be resolved for balance verification');
+    return false;
+  }
+
+  const verification = runMoltbankWrapper(skillDir, [
+    'call',
+    'MoltBank.get_balance',
+    `organizationName=${existing.activeOrg}`,
+    'date=today'
+  ]);
+
+  if (verification.ok) {
+    api.logger.info(`[moltbank] ✓ balance verification passed (org: ${existing.activeOrg})`);
+    return true;
+  }
+
+  api.logger.warn('[moltbank] ✗ setup incomplete: auth is linked, but balance verification failed (`MoltBank.get_balance`)');
+  const detail = verification.stderr || verification.stdout;
+  if (detail) {
+    api.logger.warn('[moltbank] verification detail: ' + detail);
+  }
+  return false;
+}
+
 function startBackgroundOauthPoll(
   skillDir: string,
   appBaseUrl: string,
@@ -601,12 +892,7 @@ function startBackgroundOauthPoll(
     oauthPollers.delete(skillDir);
     const after = parseActiveTokenFromCredentials();
     if (after.ok) {
-      const pendingPath = join(skillDir, '.oauth_device_code.json');
-      try {
-        if (existsSync(pendingPath)) unlinkSync(pendingPath);
-      } catch {
-        // ignore
-      }
+      clearPendingOauthCode(skillDir);
       api.logger.info(`[moltbank] ✓ background onboarding completed (active org: ${after.activeOrg})`);
       try {
         startBackgroundFinalizeAfterAuth(skillDir, appBaseUrl, api);
@@ -686,6 +972,8 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
   const existing = parseActiveTokenFromCredentials();
   if (existing.ok) {
     stopBackgroundOauthPoll(skillDir);
+    stopBackgroundFinalize(skillDir);
+    clearPendingOauthCode(skillDir);
     api.logger.info(`[moltbank] ✓ credentials.json already available (active org: ${existing.activeOrg})`);
     return true;
   }
@@ -824,11 +1112,7 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
 
     if (oauthError === 'invalid_grant') {
       api.logger.warn('[moltbank] ✗ onboarding code expired or already consumed (invalid_grant)');
-      try {
-        if (existsSync(pendingPath)) unlinkSync(pendingPath);
-      } catch {
-        // ignore
-      }
+      clearPendingOauthCode(skillDir);
     } else {
       api.logger.warn('[moltbank] ✗ onboarding poll failed or timed out');
     }
@@ -845,11 +1129,7 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
     return false;
   }
 
-  try {
-    if (existsSync(pendingPath)) unlinkSync(pendingPath);
-  } catch {
-    // ignore
-  }
+  clearPendingOauthCode(skillDir);
 
   api.logger.info(`[moltbank] ✓ onboarding completed (active org: ${after.activeOrg})`);
   return true;
@@ -858,7 +1138,10 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
 export function printAuthStatus(skillDir: string, appBaseUrl: string, api: LoggerApi): void {
   const now = Math.floor(Date.now() / 1000);
   const existing = parseActiveTokenFromCredentials();
-  const pending = readPendingOauthCode(skillDir);
+  if (existing.ok) {
+    clearPendingOauthCode(skillDir);
+  }
+  const pending = existing.ok ? null : readPendingOauthCode(skillDir);
   const poller = oauthPollers.get(skillDir);
   const finalizer = backgroundFinalizers.get(skillDir);
   const pollerRunning = Boolean(poller && poller.exitCode === null && !poller.killed);
@@ -1228,6 +1511,11 @@ export async function runSetup(
     } else {
       api.logger.info('[moltbank] sandbox unchanged — no restart needed');
     }
+
+    api.logger.info('[moltbank] [sandbox 11/11] verifying authenticated balance read...');
+    if (!verifyMoltbankOperationalReadiness(skillDir, api)) {
+      return;
+    }
   } else {
     api.logger.info('[moltbank] [host 1/8] ensuring mcporter on host...');
     ensureMcporter(api);
@@ -1270,19 +1558,11 @@ export async function runSetup(
     api.logger.info('[moltbank] [host 7/8] writing/registering mcporter config...');
     ensureMcporterConfig(skillDir, appBaseUrl, api);
 
-    api.logger.info('[moltbank] [host 8/8] running wrapper smoke test...');
-    // FIX: usar path absoluto para el .ps1 en Windows
-    const ps1Path = join(skillDir, 'scripts', 'moltbank.ps1');
-    const smokeCmd = IS_WIN
-      ? `powershell -NoProfile -ExecutionPolicy Bypass -File "${ps1Path}" list MoltBank`
-      : `"${skillDir}/scripts/moltbank.sh" list MoltBank`;
-    const smoke = run(smokeCmd, { cwd: skillDir, silent: true });
-    if (!smoke.ok) {
-      api.logger.warn('[moltbank] host setup incomplete: smoke test failed (`moltbank list MoltBank` via platform script)');
-    } else {
-      api.logger.info('[moltbank] host smoke test passed (`moltbank list MoltBank`)');
+    api.logger.info('[moltbank] [host 8/8] verifying authenticated balance read...');
+    hostReady = verifyMoltbankOperationalReadiness(skillDir, api);
+    if (!hostReady) {
+      return;
     }
-    hostReady = smoke.ok;
 
     api.logger.info('[moltbank] host mode — setup completed with onboarding flow');
   }
@@ -1357,19 +1637,15 @@ export default function register(api: PluginApi) {
         .addCommand(
           program
             .createCommand('setup')
-            .description('Re-run MoltBank setup (nonblocking auth by default)')
+            .description('Re-run MoltBank setup')
             .action(async () => {
-              console.log('Running MoltBank setup...');
-              const authWaitMode = getSetupAuthWaitMode('nonblocking');
-              if (authWaitMode === 'nonblocking') {
-                console.log('[moltbank] setup auth mode: nonblocking (default for channel reliability)');
-                console.log('[moltbank] set MOLTBANK_SETUP_AUTH_WAIT_MODE=blocking to wait for OAuth approval');
-                console.log('[moltbank] after browser approval, setup finalization continues automatically');
-                console.log('[moltbank] optional immediate check: openclaw moltbank auth-status');
-              } else {
-                console.log('[moltbank] setup auth mode: blocking (waiting for OAuth approval)');
+              const verbose = process.argv.includes('--verbose');
+              const logger = createSetupCommandLogger({ verbose, statusCommand: 'openclaw moltbank status' });
+              try {
+                await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+              } finally {
+                logger.finish();
               }
-              await runSetup(cfg, { logger: console }, { authWaitMode });
             })
         )
         .addCommand(
@@ -1377,8 +1653,13 @@ export default function register(api: PluginApi) {
             .createCommand('setup-blocking')
             .description('Re-run full MoltBank setup and wait for OAuth approval')
             .action(async () => {
-              console.log('Running MoltBank setup (blocking auth mode)...');
-              await runSetup(cfg, { logger: console }, { authWaitMode: 'blocking' });
+              const verbose = process.argv.includes('--verbose');
+              const logger = createSetupCommandLogger({ verbose, statusCommand: 'openclaw moltbank status' });
+              try {
+                await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+              } finally {
+                logger.finish();
+              }
             })
         )
         .addCommand(
@@ -1408,6 +1689,16 @@ export default function register(api: PluginApi) {
               }
             })
         )
+        .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')

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moltbankhq/openclaw",
-    "version": "0.1.6",
+    "version": "0.1.8",
     "description": "MoltBank stablecoin treasury CLI and OpenClaw plugin",
     "main": "index.ts",
     "bin": {