@moltbankhq/openclaw 0.1.6 → 0.1.7

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

@@ -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;
 }
@@ -1357,19 +1570,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 +1586,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 +1622,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.7",
     "description": "MoltBank stablecoin treasury CLI and OpenClaw plugin",
     "main": "index.ts",
     "bin": {