@moltbankhq/openclaw 0.1.9 → 0.1.10

package/bin/moltbank.mjs

@@ -3,14 +3,15 @@
 import { createRequire } from 'module';
 import { spawnSync } from 'child_process';
 import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 
 const binDir = dirname(fileURLToPath(import.meta.url));
 const cliPath = resolve(binDir, '../cli.ts');
 const require = createRequire(import.meta.url);
 const tsxImportPath = require.resolve('tsx/esm');
+const tsxImportUrl = pathToFileURL(tsxImportPath).href;
 
-const result = spawnSync(process.execPath, ['--import', tsxImportPath, cliPath, ...process.argv.slice(2)], {
+const result = spawnSync(process.execPath, ['--import', tsxImportUrl, cliPath, ...process.argv.slice(2)], {
   stdio: 'inherit',
   env: process.env
 });
@@ -20,4 +21,4 @@ if (result.error) {
   process.exit(1);
 }
 
-process.exit(result.status ?? 1);
+process.exit(result.status ?? 1);

package/cli.ts

@@ -5,6 +5,7 @@ import {
   createSetupCommandLogger,
   ensureMcporterConfig,
   getAppBaseUrl,
+  getSetupGatewayRestartEnabled,
   getSkillDir,
   injectSandboxEnv,
   printAuthStatus,
@@ -23,6 +24,7 @@ type ParsedArgs = {
   help: boolean;
   version: boolean;
   blocking: boolean;
+  restartGateway: boolean | null;
   verbose: boolean;
 };
 
@@ -44,6 +46,8 @@ Options:
   --app-base-url <url>  Override MoltBank deployment URL
   --skill-name <name>   Override skill folder name
   --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
   --verbose             Show detailed setup logs
   -h, --help            Show help
   -v, --version         Show package version
@@ -67,6 +71,7 @@ function parseArgs(argv: string[]): ParsedArgs {
   let help = false;
   let version = false;
   let blocking = false;
+  let restartGateway: boolean | null = null;
   let verbose = false;
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -87,6 +92,16 @@ function parseArgs(argv: string[]): ParsedArgs {
       continue;
     }
 
+    if (arg === '--restart-gateway') {
+      restartGateway = true;
+      continue;
+    }
+
+    if (arg === '--no-restart-gateway') {
+      restartGateway = false;
+      continue;
+    }
+
     if (arg === '--verbose') {
       verbose = true;
       continue;
@@ -135,6 +150,7 @@ function parseArgs(argv: string[]): ParsedArgs {
     help,
     version,
     blocking,
+    restartGateway,
     verbose
   };
 }
@@ -144,9 +160,10 @@ async function runCommand(parsed: ParsedArgs): Promise<void> {
 
   switch (parsed.command) {
     case 'setup': {
+      const restartGatewayOnSuccess = parsed.restartGateway ?? getSetupGatewayRestartEnabled(process.platform === 'win32');
       const logger = createSetupCommandLogger({ verbose: parsed.verbose, statusCommand: 'moltbank status' });
       try {
-        await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+        await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
       } finally {
         logger.finish();
       }
@@ -154,9 +171,10 @@ async function runCommand(parsed: ParsedArgs): Promise<void> {
     }
 
     case 'setup-blocking': {
+      const restartGatewayOnSuccess = parsed.restartGateway ?? getSetupGatewayRestartEnabled(process.platform === 'win32');
       const logger = createSetupCommandLogger({ verbose: parsed.verbose, statusCommand: 'moltbank status' });
       try {
-        await runSetup(cfg, logger, { authWaitMode: 'blocking' });
+        await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
       } finally {
         logger.finish();
       }
@@ -223,4 +241,4 @@ main().catch((error: unknown) => {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`[moltbank] ${message}`);
   process.exit(1);
-});
+});

package/index.ts

@@ -1,5 +1,5 @@
-import { execSync, spawn, spawnSync } from 'child_process';
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { execSync, spawn } from 'child_process';
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 const IS_WIN = process.platform === 'win32';
@@ -306,33 +306,68 @@ export function getSetupAuthWaitMode(defaultMode: AuthWaitMode): AuthWaitMode {
   return defaultMode;
 }
 
+function parseBooleanEnv(raw: string): boolean | null {
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized) return null;
+
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
+  return null;
+}
+
+export function getSetupGatewayRestartEnabled(defaultEnabled: boolean): boolean {
+  const parsed = parseBooleanEnv(asString(process.env.MOLTBANK_SETUP_RESTART_GATEWAY));
+  return parsed === null ? defaultEnabled : parsed;
+}
+
+function getExecOutputText(error: unknown, field: 'stderr' | 'stdout'): string {
+  if (!isRecord(error) || !(field in error)) return '';
+
+  const raw = (error as { stderr?: unknown; stdout?: unknown })[field];
+  if (typeof raw === 'string') return raw.trim();
+  if (Buffer.isBuffer(raw)) return raw.toString('utf8').trim();
+
+  if (isRecord(raw) && 'toString' in raw && typeof (raw as { toString?: unknown }).toString === 'function') {
+    const text = (raw as { toString: () => string }).toString().trim();
+    if (text && text !== '[object Object]') return text;
+  }
+
+  return '';
+}
+
 function getExecErrorMessage(error: unknown): string {
-  if (isRecord(error) && 'stderr' in error) {
-    const stderr = (error as { stderr?: unknown }).stderr;
-    if (typeof stderr === 'string') {
-      return stderr.trim();
-    }
-    if (isRecord(stderr) && 'toString' in stderr && typeof (stderr as { toString?: unknown }).toString === 'function') {
-      return (stderr as { toString: () => string }).toString().trim();
-    }
+  const stderr = getExecOutputText(error, 'stderr');
+  if (stderr) return stderr;
+
+  const stdout = getExecOutputText(error, 'stdout');
+  if (stdout) return stdout;
+
+  if (isRecord(error) && 'message' in error) {
+    const message = asString((error as { message?: unknown }).message).trim();
+    if (message) return message;
   }
+
   return String(error);
 }
 
-function run(cmd: string, opts: { cwd?: string; silent?: boolean; env?: Record<string, string | undefined> } = {}) {
+function run(
+  cmd: string,
+  opts: { cwd?: string; silent?: boolean; env?: Record<string, string | undefined>; timeoutMs?: number } = {}
+) {
   try {
     const mergedEnv: NodeJS.ProcessEnv = { ...process.env, ...(opts.env ?? {}) };
     const out = execSync(cmd, {
       cwd: opts.cwd,
       stdio: opts.silent ? 'pipe' : 'inherit',
       env: mergedEnv,
+      timeout: opts.timeoutMs,
       shell: IS_WIN ? (process.env.ComSpec ?? 'cmd.exe') : '/bin/bash'
     });
     return { ok: true, stdout: out?.toString().trim() ?? '' };
   } catch (e: unknown) {
     return {
       ok: false,
-      stdout: '',
+      stdout: getExecOutputText(e, 'stdout'),
       stderr: getExecErrorMessage(e)
     };
   }
@@ -342,6 +377,171 @@ function hasBin(bin: string) {
   return run(IS_WIN ? `where ${bin}` : `which ${bin}`, { silent: true }).ok;
 }
 
+function getJqInstallHint(): string {
+  if (hasBin('apt-get')) return '`sudo apt-get install -y jq`';
+  if (hasBin('dnf')) return '`sudo dnf install -y jq`';
+  if (hasBin('yum')) return '`sudo yum install -y jq`';
+  if (hasBin('pacman')) return '`sudo pacman -S --noconfirm jq`';
+  if (hasBin('apk')) return '`sudo apk add jq`';
+  if (hasBin('zypper')) return '`sudo zypper install -y jq`';
+  if (hasBin('brew')) return '`brew install jq`';
+  return 'using your distro package manager';
+}
+
+function splitNonEmptyLines(text: string): string[] {
+  return (text || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function getNpmGlobalBinDir(): string {
+  const prefix = run('npm config get prefix', { silent: true });
+  if (!prefix.ok) return '';
+
+  const value = prefix.stdout.trim();
+  if (!value || value === 'undefined' || value === 'null') return '';
+  return IS_WIN ? value : join(value, 'bin');
+}
+
+function findFirstMatchingFile(rootDir: string, predicate: (name: string) => boolean, maxDepth = 3): string {
+  if (!rootDir || !existsSync(rootDir)) return '';
+
+  const queue: Array<{ dir: string; depth: number }> = [{ dir: rootDir, depth: 0 }];
+  while (queue.length) {
+    const current = queue.shift();
+    if (!current) break;
+
+    let entries: ReturnType<typeof readdirSync>;
+    try {
+      entries = readdirSync(current.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(current.dir, entry.name);
+      if (entry.isFile() && predicate(entry.name)) {
+        return fullPath;
+      }
+      if (entry.isDirectory() && current.depth < maxDepth) {
+        queue.push({ dir: fullPath, depth: current.depth + 1 });
+      }
+    }
+  }
+
+  return '';
+}
+
+function findWindowsJqBinaryPath(): string {
+  if (!IS_WIN) return '';
+
+  const fromEnv = asString(process.env.JQ_PATH).trim();
+  if (fromEnv && existsSync(fromEnv)) return fromEnv;
+
+  const whereJq = run('where jq', { silent: true });
+  if (whereJq.ok) {
+    for (const line of splitNonEmptyLines(whereJq.stdout)) {
+      if (existsSync(line)) {
+        return line;
+      }
+    }
+  }
+
+  const localAppData = asString(process.env.LOCALAPPDATA).trim();
+  const appData = asString(process.env.APPDATA).trim();
+  const userProfile = asString(process.env.USERPROFILE).trim();
+  const programData = asString(process.env.ProgramData).trim();
+  const programFiles = asString(process.env.ProgramFiles).trim();
+  const chocolateyInstall = asString(process.env.ChocolateyInstall).trim();
+
+  const candidates = [
+    localAppData ? join(localAppData, 'Microsoft', 'WinGet', 'Links', 'jq.exe') : '',
+    localAppData ? join(localAppData, 'Microsoft', 'WindowsApps', 'jq.exe') : '',
+    localAppData ? join(localAppData, 'Programs', 'jq', 'jq.exe') : '',
+    localAppData ? join(localAppData, 'Programs', 'jqlang', 'jq.exe') : '',
+    appData ? join(appData, 'npm', 'jq.exe') : '',
+    appData ? join(appData, 'npm', 'jq.cmd') : '',
+    userProfile ? join(userProfile, 'scoop', 'shims', 'jq.exe') : '',
+    chocolateyInstall ? join(chocolateyInstall, 'bin', 'jq.exe') : '',
+    programData ? join(programData, 'chocolatey', 'bin', 'jq.exe') : '',
+    programFiles ? join(programFiles, 'jqlang', 'jq.exe') : '',
+    programFiles ? join(programFiles, 'jq', 'jq.exe') : ''
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  const isJqExecutable = (name: string): boolean => {
+    const lower = name.toLowerCase();
+    return lower === 'jq.exe' || lower === 'jq-windows-amd64.exe' || (lower.startsWith('jq') && lower.endsWith('.exe'));
+  };
+
+  const wingetPackagesRoot = localAppData ? join(localAppData, 'Microsoft', 'WinGet', 'Packages') : '';
+  if (wingetPackagesRoot && existsSync(wingetPackagesRoot)) {
+    let packageEntries: ReturnType<typeof readdirSync> = [];
+    try {
+      packageEntries = readdirSync(wingetPackagesRoot, { withFileTypes: true });
+    } catch {
+      packageEntries = [];
+    }
+
+    for (const entry of packageEntries) {
+      if (!entry.isDirectory()) continue;
+      const lower = entry.name.toLowerCase();
+      if (!lower.includes('jqlang.jq') && !lower.startsWith('jq')) continue;
+
+      const found = findFirstMatchingFile(join(wingetPackagesRoot, entry.name), isJqExecutable, 3);
+      if (found) return found;
+    }
+
+    const fallback = findFirstMatchingFile(wingetPackagesRoot, isJqExecutable, 2);
+    if (fallback) return fallback;
+  }
+
+  return '';
+}
+
+function ensureWindowsJqShim(api: LoggerApi): boolean {
+  if (!IS_WIN) return false;
+
+  const jqSourcePath = findWindowsJqBinaryPath();
+  if (!jqSourcePath) return false;
+
+  const npmBinDir = getNpmGlobalBinDir();
+  if (!npmBinDir) return false;
+
+  const shimPath = join(npmBinDir, 'jq.cmd');
+  try {
+    mkdirSync(npmBinDir, { recursive: true });
+    if (jqSourcePath.toLowerCase() !== shimPath.toLowerCase()) {
+      const escapedSource = jqSourcePath.replace(/"/g, '""');
+      const shimBody = `@echo off\r\n"${escapedSource}" %*\r\n`;
+      writeFileSync(shimPath, shimBody, 'utf8');
+    }
+  } catch (e) {
+    api.logger.warn('[moltbank] could not create jq shim in npm global bin: ' + String(e));
+    return false;
+  }
+
+  if (!hasBin('jq')) return false;
+
+  const v = run('jq --version', { silent: true });
+  api.logger.info(`[moltbank] ✓ jq available via npm global bin shim (${v.stdout || 'unknown version'})`);
+  return true;
+}
+
+function lastNonEmptyLine(text: string): string {
+  const lines = text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return lines.length ? lines[lines.length - 1] : '';
+}
+
 function getWorkspace(): string {
   return process.env.OPENCLAW_WORKSPACE || join(homedir(), '.openclaw', 'workspace');
 }
@@ -478,6 +678,105 @@ function ensureMcporter(api: LoggerApi) {
   }
 }
 
+function ensureJq(api: LoggerApi) {
+  if (hasBin('jq')) {
+    const v = run('jq --version', { silent: true });
+    api.logger.info(`[moltbank] ✓ jq already installed (${v.stdout || 'unknown version'})`);
+    return;
+  }
+
+  if (!IS_WIN) {
+    api.logger.warn('[moltbank] ✗ jq not found in PATH (required by MoltBank wrapper on host mode)');
+    api.logger.warn(`[moltbank]   install jq (${getJqInstallHint()}) and rerun setup`);
+    return;
+  }
+
+  if (ensureWindowsJqShim(api)) {
+    api.logger.info('[moltbank] ✓ jq found on disk and shimmed into current PATH scope');
+    return;
+  }
+
+  api.logger.info('[moltbank] jq not found — attempting Windows install...');
+
+  const installers: Array<{ name: string; checkCmd: string; installCmd: string }> = [
+    {
+      name: 'winget',
+      checkCmd: 'where winget',
+      installCmd: 'winget install -e --id jqlang.jq --accept-package-agreements --accept-source-agreements --silent'
+    },
+    {
+      name: 'scoop',
+      checkCmd: 'where scoop',
+      installCmd: 'scoop install jq'
+    },
+    {
+      name: 'choco',
+      checkCmd: 'where choco',
+      installCmd: 'choco install jq -y'
+    }
+  ];
+
+  for (const installer of installers) {
+    if (!run(installer.checkCmd, { silent: true }).ok) continue;
+
+    api.logger.info(`[moltbank] trying jq install via ${installer.name}...`);
+    const install = run(installer.installCmd, { timeoutMs: 180000 });
+    const installOutput = `${install.stdout}\n${install.stderr}`;
+    const installOutputLower = installOutput.toLowerCase();
+    const alreadyInstalledOrNoUpdate =
+      installOutputLower.includes('already installed') ||
+      installOutputLower.includes('paquete existente ya instalado') ||
+      installOutputLower.includes('no update available') ||
+      installOutputLower.includes('no updates available') ||
+      installOutputLower.includes('no newer package versions are available') ||
+      installOutputLower.includes('no se ha encontrado ninguna actualización disponible') ||
+      installOutputLower.includes('no hay versiones más recientes');
+
+    if (!install.ok) {
+      if (!alreadyInstalledOrNoUpdate) {
+        api.logger.warn(`[moltbank] jq install via ${installer.name} failed: ${install.stderr}`);
+        continue;
+      }
+      api.logger.info(`[moltbank] jq already installed via ${installer.name}; validating availability...`);
+    }
+
+    if (hasBin('jq')) {
+      const v = run('jq --version', { silent: true });
+      api.logger.info(`[moltbank] ✓ jq installed via ${installer.name} (${v.stdout || 'unknown version'})`);
+      return;
+    }
+
+    if (ensureWindowsJqShim(api)) {
+      api.logger.info(`[moltbank] ✓ jq installed via ${installer.name} and made available without shell restart`);
+      return;
+    }
+
+    if (alreadyInstalledOrNoUpdate) {
+      api.logger.warn(`[moltbank] jq appears installed via ${installer.name}, but is not visible in the current PATH`);
+      api.logger.warn('[moltbank]   close and reopen PowerShell, then run: `where jq`');
+      return;
+    }
+
+    const installOutputLowerCheck = installOutputLower;
+    const shellRestartNeeded =
+      installOutputLowerCheck.includes('variable de entorno path modificada') ||
+      installOutputLowerCheck.includes('path modificada') ||
+      installOutputLowerCheck.includes('path modified') ||
+      installOutputLowerCheck.includes('reinicie el shell') ||
+      installOutputLowerCheck.includes('restart the shell') ||
+      installOutputLowerCheck.includes('restart your shell');
+
+    if (shellRestartNeeded) {
+      api.logger.warn(`[moltbank] jq was installed via ${installer.name}, but this terminal has a stale PATH`);
+      api.logger.warn('[moltbank]   close and reopen PowerShell, then run: `jq --version`');
+      return;
+    }
+  }
+
+  api.logger.warn('[moltbank] ✗ jq is still missing after auto-install attempts');
+  api.logger.warn('[moltbank]   install manually on Windows: winget install jqlang.jq');
+}
+
 function ensureWrapperExecutable(skillDir: string, api: LoggerApi): void {
   if (IS_WIN) return;
   const wrapperPath = join(skillDir, 'scripts', 'moltbank.sh');
@@ -498,7 +797,6 @@ const SKILL_FILES = [
   'SKILL.md',
   'skill.json',
   'install.sh',
-  'package.json',
   'assets/mcporter.json',
   'references/heartbeat.md',
   'references/onboarding.md',
@@ -700,6 +998,31 @@ function isMoltBankRegistered(): boolean {
   return result.stdout.toLowerCase().includes('moltbank');
 }
 
+function removeHomeScopedMoltBankConfig(api: LoggerApi): boolean {
+  const configPath = join(homedir(), '.mcporter', 'mcporter.json');
+  if (!existsSync(configPath)) {
+    return false;
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, 'utf8')) as unknown;
+    if (!isRecord(parsed)) return false;
+
+    const mcpServers = parsed.mcpServers;
+    if (!isRecord(mcpServers) || !('MoltBank' in mcpServers)) {
+      return false;
+    }
+
+    delete mcpServers.MoltBank;
+    writeFileSync(configPath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
+    api.logger.info('[moltbank] ✓ removed stale home-scoped mcporter MoltBank config');
+    return true;
+  } catch (e) {
+    api.logger.warn('[moltbank] could not clean home-scoped mcporter MoltBank config: ' + String(e));
+    return false;
+  }
+}
+
 function parseActiveTokenFromCredentials(): {
   ok: boolean;
   activeOrg?: string;
@@ -764,93 +1087,6 @@ 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[],
-  env: Record<string, string | undefined> = {}
-) {
-  if (IS_WIN) {
-    const ps1Path = join(skillDir, 'scripts', 'moltbank.ps1');
-    return runProcess('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', ps1Path, ...args], {
-      cwd: skillDir,
-      silent: true,
-      env
-    });
-  }
-
-  return runProcess(join(skillDir, 'scripts', 'moltbank.sh'), args, {
-    cwd: skillDir,
-    silent: true,
-    env
-  });
-}
-
-function verifyMoltbankOperationalReadiness(skillDir: string, api: LoggerApi): boolean {
-  const existing = parseActiveTokenFromCredentials();
-  if (!existing.ok || !existing.activeOrg || !existing.token) {
-    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'
-  ], {
-    MOLTBANK: existing.token,
-    ACTIVE_ORG_OVERRIDE: existing.activeOrg
-  });
-
-  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,
@@ -902,7 +1138,12 @@ function startBackgroundOauthPoll(
     oauthPollers.delete(skillDir);
     const after = parseActiveTokenFromCredentials();
     if (after.ok) {
-      clearPendingOauthCode(skillDir);
+      const pendingPath = join(skillDir, '.oauth_device_code.json');
+      try {
+        if (existsSync(pendingPath)) unlinkSync(pendingPath);
+      } catch {
+        // ignore
+      }
       api.logger.info(`[moltbank] ✓ background onboarding completed (active org: ${after.activeOrg})`);
       try {
         startBackgroundFinalizeAfterAuth(skillDir, appBaseUrl, api);
@@ -982,8 +1223,6 @@ 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;
   }
@@ -1122,7 +1361,11 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
 
     if (oauthError === 'invalid_grant') {
       api.logger.warn('[moltbank] ✗ onboarding code expired or already consumed (invalid_grant)');
-      clearPendingOauthCode(skillDir);
+      try {
+        if (existsSync(pendingPath)) unlinkSync(pendingPath);
+      } catch {
+        // ignore
+      }
     } else {
       api.logger.warn('[moltbank] ✗ onboarding poll failed or timed out');
     }
@@ -1139,7 +1382,11 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
     return false;
   }
 
-  clearPendingOauthCode(skillDir);
+  try {
+    if (existsSync(pendingPath)) unlinkSync(pendingPath);
+  } catch {
+    // ignore
+  }
 
   api.logger.info(`[moltbank] ✓ onboarding completed (active org: ${after.activeOrg})`);
   return true;
@@ -1148,10 +1395,7 @@ 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();
-  if (existing.ok) {
-    clearPendingOauthCode(skillDir);
-  }
-  const pending = existing.ok ? null : readPendingOauthCode(skillDir);
+  const pending = readPendingOauthCode(skillDir);
   const poller = oauthPollers.get(skillDir);
   const finalizer = backgroundFinalizers.get(skillDir);
   const pollerRunning = Boolean(poller && poller.exitCode === null && !poller.killed);
@@ -1202,35 +1446,12 @@ export function ensureMcporterConfig(skillDir: string, appBaseUrl: string, api:
   api.logger.info('[moltbank] ✓ mcporter.json written: ' + cfgPath);
 
   if (!hasBin('mcporter')) {
-    api.logger.warn('[moltbank] ✗ mcporter not in PATH — cannot register');
+    api.logger.warn('[moltbank] ✗ mcporter not in PATH — cannot validate local config usage');
     return;
   }
 
-  if (isMoltBankRegistered()) {
-    api.logger.info('[moltbank] ✓ MoltBank already registered in mcporter');
-    return;
-  }
-
-  api.logger.info('[moltbank] registering MoltBank in mcporter (scope: home)...');
-
-  const addCmd =
-    `mcporter config add MoltBank ` +
-    `--url "${appBaseUrl}/api/mcp" ` +
-    `--transport sse ` +
-    `--header "Authorization=Bearer \${MOLTBANK}" ` +
-    `--header "Content-Type=application/json" ` +
-    `--description "MoltBank stablecoin treasury MCP server powered by Fondu" ` +
-    `--scope home`;
-
-  const result = run(addCmd, { silent: false });
-
-  if (result.ok) {
-    api.logger.info('[moltbank] ✓ MoltBank registered in mcporter');
-    const list = run('mcporter config list', { silent: true });
-    api.logger.info('[moltbank] mcporter config list: ' + list.stdout);
-  } else {
-    api.logger.warn('[moltbank] ✗ mcporter config add failed: ' + result.stderr);
-  }
+  removeHomeScopedMoltBankConfig(api);
+  api.logger.info('[moltbank] ✓ MoltBank will use skill-local mcporter config only');
 }
 
 // ─── sandbox env vars ────────────────────────────────────────────────────────
@@ -1438,12 +1659,29 @@ export function recreateSandboxAndRestart(api: LoggerApi) {
   }, 8000);
 }
 
+function restartGatewayAfterHostSetup(api: LoggerApi): boolean {
+  api.logger.info('[moltbank] restarting gateway to refresh host skill state...');
+  const restart = run('openclaw gateway restart', { silent: true, timeoutMs: 30000 });
+  if (restart.ok) {
+    api.logger.info('[moltbank] ✓ gateway restarted');
+    return true;
+  }
+
+  const combined = `${restart.stderr}\n${restart.stdout}`.trim();
+  const detail = lastNonEmptyLine(combined);
+  if (detail) {
+    api.logger.warn(`[moltbank] gateway restart detail: ${detail}`);
+  }
+  api.logger.warn('[moltbank] could not restart gateway automatically; run `openclaw gateway restart`');
+  return false;
+}
+
 // ─── main setup ───────────────────────────────────────────────────────────────
 
 export async function runSetup(
   cfg: MoltbankPluginConfig,
   api: LoggerApi,
-  options: { authWaitMode?: AuthWaitMode } = {}
+  options: { authWaitMode?: AuthWaitMode; restartGatewayOnSuccess?: boolean } = {}
 ) {
   let hostReady = false;
   const appBaseUrl = getAppBaseUrl(cfg);
@@ -1452,6 +1690,7 @@ export async function runSetup(
   const sandbox = isSandboxEnabled();
   const skillDir = getSkillDir(cfg);
   const waitForAuth = (options.authWaitMode ?? 'blocking') === 'blocking';
+  const restartGatewayOnSuccess = Boolean(options.restartGatewayOnSuccess);
 
   api.logger.info(`[moltbank] ══════════════════════════════════════`);
   api.logger.info(`[moltbank] MoltBank setup starting`);
@@ -1467,6 +1706,7 @@ export async function runSetup(
 
     api.logger.info('[moltbank] [sandbox 0/10] ensuring mcporter on host...');
     ensureMcporter(api);
+    ensureJq(api);
 
     api.logger.info('[moltbank] [sandbox 1/10] installing skill files...');
     const skillInstalled = ensureSkillInstalled(skillDir, skillBundleBaseUrl, skillName, api, 'sandbox');
@@ -1521,14 +1761,10 @@ 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);
+    ensureJq(api);
 
     api.logger.info('[moltbank] [host 2/8] installing skill files...');
     const installed = ensureSkillInstalled(skillDir, skillBundleBaseUrl, skillName, api, 'host');
@@ -1568,13 +1804,96 @@ 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] verifying authenticated balance read...');
-    hostReady = verifyMoltbankOperationalReadiness(skillDir, api);
-    if (!hostReady) {
-      return;
+    api.logger.info('[moltbank] [host 8/8] running wrapper smoke test...');
+    const smokeTimeoutMs = IS_WIN ? 15000 : 20000;
+    let smokeOk = false;
+
+    if (IS_WIN) {
+      const mcporterConfigPath = join(skillDir, 'assets', 'mcporter.json');
+      const active = parseActiveTokenFromCredentials();
+      const mcpSmoke = run(`mcporter --config "${mcporterConfigPath}" list MoltBank`, {
+        cwd: skillDir,
+        silent: true,
+        timeoutMs: smokeTimeoutMs,
+        env: {
+          MOLTBANK: active.token ?? '__MOLTBANK_PLACEHOLDER__'
+        }
+      });
+
+      if (mcpSmoke.ok) {
+        api.logger.info('[moltbank] host smoke test passed (`mcporter list MoltBank`)');
+        smokeOk = true;
+      } else {
+        const mcpCombined = `${mcpSmoke.stderr}\n${mcpSmoke.stdout}`.trim();
+        const mcpCombinedLower = mcpCombined.toLowerCase();
+        const mcpDetail = lastNonEmptyLine(mcpCombined);
+        if (mcpDetail) {
+          api.logger.warn(`[moltbank] smoke detail: ${mcpDetail}`);
+        }
+
+        const timedOut = mcpSmoke.stderr.includes('ETIMEDOUT') || mcpCombinedLower.includes('timed out');
+        if (timedOut) {
+          api.logger.warn(
+            `[moltbank] host MCP smoke timed out after ${Math.floor(smokeTimeoutMs / 1000)}s; running local fallback checks`
+          );
+
+          const ps1Path = join(skillDir, 'scripts', 'moltbank.ps1');
+          const fallback = run(
+            'powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command "$ErrorActionPreference = \'Stop\'; if (-not (Test-Path -LiteralPath $env:MOLTBANK_WRAPPER_PATH)) { throw \'moltbank.ps1 not found\' }; if (-not (Get-Command bash -ErrorAction SilentlyContinue)) { throw \'bash is not installed or not on PATH\' }; if (-not (Get-Command mcporter -ErrorAction SilentlyContinue)) { throw \'mcporter is not installed or not on PATH\' }; Write-Output \'ok\'"',
+            {
+              cwd: skillDir,
+              silent: true,
+              timeoutMs: 10000,
+              env: { MOLTBANK_WRAPPER_PATH: ps1Path }
+            }
+          );
+
+          if (fallback.ok) {
+            api.logger.warn('[moltbank] host smoke fallback passed (wrapper prerequisites available), but MCP endpoint was not verified');
+            smokeOk = true;
+          } else {
+            const fallbackCombined = `${fallback.stderr}\n${fallback.stdout}`.trim();
+            const fallbackDetail = lastNonEmptyLine(fallbackCombined);
+            if (fallbackDetail) {
+              api.logger.warn(`[moltbank] fallback detail: ${fallbackDetail}`);
+            }
+            api.logger.warn('[moltbank] host setup incomplete: MCP smoke timed out and fallback checks failed');
+          }
+        } else if (
+          mcpCombinedLower.includes('mcporter') &&
+          (mcpCombinedLower.includes('not recognized') || mcpCombinedLower.includes('not found'))
+        ) {
+          api.logger.warn('[moltbank] mcporter binary not found in PATH during smoke test');
+        } else {
+          api.logger.warn('[moltbank] host setup incomplete: smoke test failed (`mcporter list MoltBank`)');
+        }
+      }
+    } else {
+      const smoke = run(`"${skillDir}/scripts/moltbank.sh" list MoltBank`, {
+        cwd: skillDir,
+        silent: true,
+        timeoutMs: smokeTimeoutMs
+      });
+      if (!smoke.ok) {
+        const smokeCombined = `${smoke.stderr}\n${smoke.stdout}`.trim();
+        const smokeDetail = lastNonEmptyLine(smokeCombined);
+        if (smokeDetail) {
+          api.logger.warn(`[moltbank] smoke detail: ${smokeDetail}`);
+        }
+        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`)');
+        smokeOk = true;
+      }
     }
 
+    hostReady = smokeOk;
+
     api.logger.info('[moltbank] host mode — setup completed with onboarding flow');
+
+    if (hostReady && restartGatewayOnSuccess) {
+      restartGatewayAfterHostSetup(api);
+    }
   }
 
   api.logger.info(`[moltbank] ══════════════════════════════════════`);
@@ -1650,9 +1969,10 @@ export default function register(api: PluginApi) {
             .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' });
+                await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
               } finally {
                 logger.finish();
               }
@@ -1664,9 +1984,10 @@ export default function register(api: PluginApi) {
             .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' });
+                await runSetup(cfg, logger, { authWaitMode: 'blocking', restartGatewayOnSuccess });
               } finally {
                 logger.finish();
               }

package/package.json

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