@moltbankhq/openclaw 0.1.9 → 0.1.11

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,7 +1,7 @@
-import { execSync, spawn, spawnSync } from 'child_process';
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { spawn, spawnSync } from 'child_process';
+import { chmodSync, chownSync, existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, type Dirent } from 'fs';
 import { join, dirname } from 'path';
-import { homedir } from 'os';
+import { homedir, userInfo } from 'os';
 const IS_WIN = process.platform === 'win32';
 
 type OpenclawConfig = Record<string, unknown>;
@@ -32,6 +32,21 @@ interface LoggerApi {
   logger: LoggerLike;
 }
 
+type RunOptions = {
+  cwd?: string;
+  silent?: boolean;
+  env?: Record<string, string | undefined>;
+  timeoutMs?: number;
+};
+
+type RunResult = {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  timedOut: boolean;
+};
+
 export interface SetupCommandLoggerOptions {
   verbose?: boolean;
   statusCommand?: string;
@@ -306,40 +321,355 @@ 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 runCommand(command: string, args: string[], opts: RunOptions = {}): RunResult {
   try {
     const mergedEnv: NodeJS.ProcessEnv = { ...process.env, ...(opts.env ?? {}) };
-    const out = execSync(cmd, {
+    const result = spawnSync(command, args, {
       cwd: opts.cwd,
-      stdio: opts.silent ? 'pipe' : 'inherit',
       env: mergedEnv,
-      shell: IS_WIN ? (process.env.ComSpec ?? 'cmd.exe') : '/bin/bash'
+      encoding: 'utf8',
+      timeout: opts.timeoutMs,
+      stdio: 'pipe',
+      windowsHide: true
     });
-    return { ok: true, stdout: out?.toString().trim() ?? '' };
+
+    const stdout = (result.stdout ?? '').toString();
+    const stderr = (result.stderr ?? '').toString();
+
+    if (!opts.silent) {
+      if (stdout) process.stdout.write(stdout);
+      if (stderr) process.stderr.write(stderr);
+    }
+
+    const errorMessage = result.error ? getExecErrorMessage(result.error) : '';
+    const trimmedStdout = stdout.trim();
+    const trimmedStderr = stderr.trim();
+    const timedOut = Boolean(
+      result.error &&
+        ((isRecord(result.error) && asString((result.error as { code?: unknown }).code) === 'ETIMEDOUT') ||
+          errorMessage.toLowerCase().includes('timed out'))
+    );
+
+    if (result.status === 0) {
+      return {
+        ok: true,
+        stdout: trimmedStdout,
+        stderr: trimmedStderr,
+        exitCode: result.status,
+        timedOut: false
+      };
+    }
+
+    return {
+      ok: false,
+      stdout: trimmedStdout,
+      stderr: trimmedStderr || errorMessage || trimmedStdout,
+      exitCode: typeof result.status === 'number' ? result.status : null,
+      timedOut
+    };
   } catch (e: unknown) {
     return {
       ok: false,
-      stdout: '',
-      stderr: getExecErrorMessage(e)
+      stdout: getExecOutputText(e, 'stdout'),
+      stderr: getExecErrorMessage(e),
+      exitCode: null,
+      timedOut: getExecErrorMessage(e).toLowerCase().includes('timed out')
     };
   }
 }
 
 function hasBin(bin: string) {
-  return run(IS_WIN ? `where ${bin}` : `which ${bin}`, { silent: true }).ok;
+  return runCommand(IS_WIN ? 'where' : '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 = runCommand('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: Dirent[] = [];
+    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 visitFiles(rootDir: string, visitor: (fullPath: string, entry: Dirent) => void, maxDepth = Number.POSITIVE_INFINITY): void {
+  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: Dirent[] = [];
+    try {
+      entries = readdirSync(current.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(current.dir, entry.name);
+      visitor(fullPath, entry);
+      if (entry.isDirectory() && current.depth < maxDepth) {
+        queue.push({ dir: fullPath, depth: current.depth + 1 });
+      }
+    }
+  }
+}
+
+function normalizeFileLineEndings(filePath: string): void {
+  try {
+    const original = readFileSync(filePath, 'utf8');
+    const normalized = original.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    if (normalized !== original) {
+      writeFileSync(filePath, normalized, 'utf8');
+    }
+  } catch {
+    // ignore
+  }
+}
+
+function normalizeFilesMatching(rootDir: string, matcher: (fullPath: string, entry: Dirent) => boolean, maxDepth = Number.POSITIVE_INFINITY): void {
+  visitFiles(
+    rootDir,
+    (fullPath, entry) => {
+      if (entry.isFile() && matcher(fullPath, entry)) {
+        normalizeFileLineEndings(fullPath);
+      }
+    },
+    maxDepth
+  );
+}
+
+function applyRecursiveOwnership(rootDir: string, uid: number, gid: number): void {
+  try {
+    chownSync(rootDir, uid, gid);
+  } catch {
+    // ignore
+  }
+
+  visitFiles(rootDir, (fullPath) => {
+    try {
+      chownSync(fullPath, uid, gid);
+    } catch {
+      // ignore
+    }
+  });
+}
+
+function applyRecursiveMode(rootDir: string, mode: number): void {
+  try {
+    chmodSync(rootDir, mode);
+  } catch {
+    // ignore
+  }
+
+  visitFiles(rootDir, (fullPath) => {
+    try {
+      chmodSync(fullPath, mode);
+    } catch {
+      // ignore
+    }
+  });
+}
+
+function findWindowsJqBinaryPath(): string {
+  if (!IS_WIN) return '';
+
+  const fromEnv = asString(process.env.JQ_PATH).trim();
+  if (fromEnv && existsSync(fromEnv)) return fromEnv;
+
+  const whereJq = runCommand('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: Dirent<string>[] = [];
+    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 = runCommand('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 {
@@ -465,12 +795,12 @@ function cleanupStaleMoltbankPluginLoadPaths(api: LoggerApi): boolean {
 
 function ensureMcporter(api: LoggerApi) {
   if (hasBin('mcporter')) {
-    const v = run('mcporter --version', { silent: true });
+    const v = runCommand('mcporter', ['--version'], { silent: true });
     api.logger.info(`[moltbank] ✓ mcporter already installed (${v.stdout || 'unknown version'})`);
     return;
   }
   api.logger.info('[moltbank] installing mcporter globally...');
-  const result = run('npm install -g mcporter');
+  const result = runCommand('npm', ['install', '-g', 'mcporter']);
   if (result.ok) {
     api.logger.info('[moltbank] ✓ mcporter installed');
   } else {
@@ -478,6 +808,117 @@ function ensureMcporter(api: LoggerApi) {
   }
 }
 
+function ensureJq(api: LoggerApi) {
+  if (hasBin('jq')) {
+    const v = runCommand('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;
+    checkCommand: string;
+    checkArgs: string[];
+    installCommand: string;
+    installArgs: string[];
+  }> = [
+    {
+      name: 'winget',
+      checkCommand: 'where',
+      checkArgs: ['winget'],
+      installCommand: 'winget',
+      installArgs: ['install', '-e', '--id', 'jqlang.jq', '--accept-package-agreements', '--accept-source-agreements', '--silent']
+    },
+    {
+      name: 'scoop',
+      checkCommand: 'where',
+      checkArgs: ['scoop'],
+      installCommand: 'scoop',
+      installArgs: ['install', 'jq']
+    },
+    {
+      name: 'choco',
+      checkCommand: 'where',
+      checkArgs: ['choco'],
+      installCommand: 'choco',
+      installArgs: ['install', 'jq', '-y']
+    }
+  ];
+
+  for (const installer of installers) {
+    if (!runCommand(installer.checkCommand, installer.checkArgs, { silent: true }).ok) continue;
+
+    api.logger.info(`[moltbank] trying jq install via ${installer.name}...`);
+    const install = runCommand(installer.installCommand, installer.installArgs, { 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 = runCommand('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 +939,6 @@ const SKILL_FILES = [
   'SKILL.md',
   'skill.json',
   'install.sh',
-  'package.json',
   'assets/mcporter.json',
   'references/heartbeat.md',
   'references/onboarding.md',
@@ -523,13 +963,67 @@ function hasRequiredSkillFiles(skillDir: string): boolean {
   return SKILL_FILES.every((file) => existsSync(join(skillDir, file)));
 }
 
-function ensureSkillInstalled(
+async function installSkillBundleFiles(appBaseUrl: string, skillDir: string): Promise<RunResult> {
+  const base = appBaseUrl.endsWith('/') ? appBaseUrl.slice(0, -1) : appBaseUrl;
+  const aliases: Record<string, string[]> = {
+    'SKILL.md': ['SKILL.md', 'skill.md'],
+    'skill.md': ['skill.md', 'SKILL.md']
+  };
+
+  try {
+    for (const file of SKILL_FILES) {
+      const outPath = join(skillDir, file);
+      mkdirSync(dirname(outPath), { recursive: true });
+
+      let body: string | null = null;
+      let lastUrl = '';
+      let lastStatus = '';
+      for (const candidate of aliases[file] ?? [file]) {
+        const url = `${base}/${candidate}`;
+        lastUrl = url;
+
+        const response = await fetch(url);
+        if (response.ok) {
+          body = await response.text();
+          break;
+        }
+
+        lastStatus = String(response.status);
+      }
+
+      if (body === null) {
+        return {
+          ok: false,
+          stdout: '',
+          stderr: `download failed ${lastUrl} ${lastStatus}`.trim(),
+          exitCode: 2,
+          timedOut: false
+        };
+      }
+
+      writeFileSync(outPath, body, 'utf8');
+    }
+
+    writeFileSync(join(skillDir, '.install_success'), 'ok\n', 'utf8');
+    return { ok: true, stdout: '', stderr: '', exitCode: 0, timedOut: false };
+  } catch (e) {
+    return {
+      ok: false,
+      stdout: '',
+      stderr: String(e),
+      exitCode: null,
+      timedOut: false
+    };
+  }
+}
+
+async function ensureSkillInstalled(
   skillDir: string,
   appBaseUrl: string,
   skillName: string,
   api: LoggerApi,
   mode: 'sandbox' | 'host' = 'sandbox'
-) {
+): Promise<boolean> {
   const successFlag = join(skillDir, '.install_success');
   if (existsSync(successFlag) && hasRequiredSkillFiles(skillDir)) {
     ensureWrapperExecutable(skillDir, api);
@@ -549,11 +1043,7 @@ function ensureSkillInstalled(
   api.logger.info(`[moltbank] installing skill '${skillName}' to ${skillDir} (mode: ${mode})`);
   mkdirSync(skillDir, { recursive: true });
 
-  const filesJson = JSON.stringify(SKILL_FILES).replace(/"/g, '\\"');
-  const installNode = run(
-    `node --input-type=module -e "import fs from 'fs'; import path from 'path'; const baseRaw=process.argv[1]; const dir=process.argv[2]; const files=JSON.parse(process.argv[3]); const base=baseRaw.endsWith('/') ? baseRaw.slice(0,-1) : baseRaw; const aliases={ 'SKILL.md':['SKILL.md','skill.md'], 'skill.md':['skill.md','SKILL.md'] }; fs.mkdirSync(dir,{recursive:true}); for (const f of files){ const out=path.join(dir,f); fs.mkdirSync(path.dirname(out),{recursive:true}); let body=null; let lastUrl=''; let lastStatus=''; for (const candidate of (aliases[f] ?? [f])){ const u=base+'/'+candidate; lastUrl=u; const r=await fetch(u); if(r.ok){ body=await r.text(); break; } lastStatus=String(r.status); } if(body===null){ console.error('download failed',lastUrl,lastStatus); process.exit(2);} fs.writeFileSync(out, body,'utf8'); } fs.writeFileSync(path.join(dir,'.install_success'),'ok\\n','utf8');" "${appBaseUrl}" "${skillDir}" "${filesJson}"`,
-    { cwd: dirname(skillDir), silent: true }
-  );
+  const installNode = await installSkillBundleFiles(appBaseUrl, skillDir);
 
   if (installNode.ok) {
     ensureWrapperExecutable(skillDir, api);
@@ -608,34 +1098,42 @@ function ensureSkillPermissions(skillDir: string, api: LoggerApi) {
   const referencesDir = join(skillDir, 'references');
   const scriptsDir = join(skillDir, 'scripts');
 
-  const user = run('whoami', { silent: true }).stdout;
-  if (user && existsSync(skillDir)) {
-    run(`chown -R ${user} "${skillDir}"`, { silent: true });
-    api.logger.info(`[moltbank] ✓ ownership corrected to ${user}`);
+  let currentUserName = '';
+  try {
+    const currentUser = userInfo();
+    currentUserName = currentUser.username;
+    if (existsSync(skillDir)) {
+      applyRecursiveOwnership(skillDir, currentUser.uid, currentUser.gid);
+      api.logger.info(`[moltbank] ✓ ownership corrected to ${currentUserName}`);
+    }
+  } catch {
+    // ignore ownership correction when uid/gid are unavailable
   }
 
   if (existsSync(assetsDir)) {
-    run(`chmod 777 "${assetsDir}"`, { silent: true });
+    applyRecursiveMode(assetsDir, 0o777);
     api.logger.info('[moltbank] ✓ assets/ permissions → 777');
   }
   if (existsSync(configFile)) {
-    run(`chmod 666 "${configFile}"`, { silent: true });
+    try {
+      chmodSync(configFile, 0o666);
+    } catch {
+      // ignore
+    }
     api.logger.info('[moltbank] ✓ mcporter.json permissions → 666');
   }
   if (existsSync(scriptsDir)) {
-    run(`chmod -R 755 "${scriptsDir}"`, { silent: true });
+    applyRecursiveMode(scriptsDir, 0o755);
     api.logger.info('[moltbank] ✓ scripts/ permissions → 755');
-    run(`find "${scriptsDir}" -type f -exec sed -i 's/\r$//' {} +`, {
-      silent: true
-    });
+    normalizeFilesMatching(scriptsDir, () => true);
     api.logger.info('[moltbank] ✓ scripts/ line endings normalized (CRLF → LF)');
   }
 
   if (existsSync(skillDir)) {
-    run(`find "${skillDir}" -maxdepth 1 -type f -name "*.md" -exec sed -i 's/\r$//' {} +`, { silent: true });
+    normalizeFilesMatching(skillDir, (fullPath, entry) => entry.isFile() && fullPath.endsWith('.md'), 0);
   }
   if (existsSync(referencesDir)) {
-    run(`find "${referencesDir}" -maxdepth 1 -type f -name "*.md" -exec sed -i 's/\r$//' {} +`, { silent: true });
+    normalizeFilesMatching(referencesDir, (fullPath, entry) => entry.isFile() && fullPath.endsWith('.md'), 0);
   }
   if (existsSync(skillDir) || existsSync(referencesDir)) {
     api.logger.info('[moltbank] ✓ markdown line endings normalized (CRLF → LF)');
@@ -663,7 +1161,7 @@ function ensureNpmDeps(skillDir: string, api: LoggerApi, mode: 'sandbox' | 'host
   }
   api.logger.info('[moltbank] installing npm deps...');
   if (mode === 'sandbox') {
-    const result = run('npm install --ignore-scripts', { cwd: skillDir });
+    const result = runCommand('npm', ['install', '--ignore-scripts'], { cwd: skillDir });
     if (result.ok) {
       api.logger.info('[moltbank] ✓ npm deps installed');
     } else {
@@ -674,20 +1172,20 @@ function ensureNpmDeps(skillDir: string, api: LoggerApi, mode: 'sandbox' | 'host
 
   const hasLock = existsSync(join(skillDir, 'package-lock.json')) || existsSync(join(skillDir, 'npm-shrinkwrap.json'));
   if (hasLock) {
-    const ci = run('npm ci', { cwd: skillDir });
+    const ci = runCommand('npm', ['ci'], { cwd: skillDir });
     if (ci.ok) {
       api.logger.info('[moltbank] ✓ npm deps installed with npm ci');
       return;
     }
     api.logger.warn('[moltbank] npm ci failed; trying npm install: ' + ci.stderr);
   }
-  const install = run('npm install', { cwd: skillDir });
+  const install = runCommand('npm', ['install'], { cwd: skillDir });
   if (install.ok) {
     api.logger.info('[moltbank] ✓ npm deps installed with npm install');
     return;
   }
   api.logger.warn('[moltbank] npm install failed; trying safe fallback --ignore-scripts');
-  const fallback = run('npm install --ignore-scripts', { cwd: skillDir });
+  const fallback = runCommand('npm', ['install', '--ignore-scripts'], { cwd: skillDir });
   if (fallback.ok) {
     api.logger.warn('[moltbank] npm deps installed with fallback --ignore-scripts (some packages may require postinstall)');
   } else {
@@ -696,10 +1194,35 @@ function ensureNpmDeps(skillDir: string, api: LoggerApi, mode: 'sandbox' | 'host
 }
 
 function isMoltBankRegistered(): boolean {
-  const result = run('mcporter config list', { silent: true });
+  const result = runCommand('mcporter', ['config', 'list'], { silent: true });
   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 +1287,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 +1338,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 +1423,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;
   }
@@ -1027,7 +1466,7 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
   if (!deviceCode || !userCode) {
     api.logger.info('[moltbank] no valid credentials found — starting onboarding flow...');
 
-    const requestCode = run(`"${process.execPath}" "./scripts/request-oauth-device-code.mjs"`, {
+    const requestCode = runCommand(process.execPath, ['./scripts/request-oauth-device-code.mjs'], {
       cwd: skillDir,
       silent: true,
       env: {
@@ -1102,8 +1541,9 @@ function ensureMoltbankAuth(skillDir: string, appBaseUrl: string, api: LoggerApi
   const pollIntervalSeconds = Number(process.env.MOLTBANK_OAUTH_POLL_INTERVAL_SECONDS ?? 5);
   const safePollIntervalSeconds = Number.isFinite(pollIntervalSeconds) && pollIntervalSeconds > 0 ? Math.floor(pollIntervalSeconds) : 5;
 
-  const poll = run(
-    `"${process.execPath}" "./scripts/poll-oauth-token.mjs" "${deviceCode}" ${safePollTimeoutSeconds} ${safePollIntervalSeconds} --save`,
+  const poll = runCommand(
+    process.execPath,
+    ['./scripts/poll-oauth-token.mjs', deviceCode, String(safePollTimeoutSeconds), String(safePollIntervalSeconds), '--save'],
     {
       cwd: skillDir,
       silent: true,
@@ -1122,7 +1562,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 +1583,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 +1596,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 +1647,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 ────────────────────────────────────────────────────────
@@ -1285,7 +1707,7 @@ export function injectSandboxEnv(skillDir: string, api: LoggerApi): boolean {
 
     if (!privateKey) {
       api.logger.info('[moltbank] x402_signer_private_key not found — generating EOA signer...');
-      const initResult = run(`"${process.execPath}" "./scripts/init-openclaw-signer.mjs"`, {
+      const initResult = runCommand(process.execPath, ['./scripts/init-openclaw-signer.mjs'], {
         cwd: skillDir,
         silent: true,
         env: {
@@ -1408,42 +1830,72 @@ export function configureSandbox(api: LoggerApi): boolean {
 export function recreateSandboxAndRestart(api: LoggerApi) {
   api.logger.info('[moltbank] recreating sandbox containers...');
   api.logger.info('[moltbank] ⏳ waiting 8s before recreate (hot container protection)...');
+
+  const getGatewayPids = (): string[] => {
+    const result = runCommand('pgrep', ['-f', 'openclaw-gateway'], { silent: true });
+    if (!result.ok) return [];
+    return splitNonEmptyLines(result.stdout).filter((pid) => /^\d+$/.test(pid));
+  };
+
   setTimeout(() => {
     api.logger.info('[moltbank] stopping gateway...');
-    run('openclaw gateway stop', { silent: true });
-
-    const stillRunning = run("ps aux | grep openclaw-gateway | grep -v grep | awk '{print $2}'", { silent: true });
-    if (stillRunning.stdout.trim()) {
-      api.logger.info(`[moltbank] gateway still running (pids: ${stillRunning.stdout.trim()}) — sending SIGKILL...`);
-      run("kill -9 $(ps aux | grep openclaw-gateway | grep -v grep | awk '{print $2}') 2>/dev/null || true", { silent: true });
+    runCommand('openclaw', ['gateway', 'stop'], { silent: true });
+
+    const stillRunning = getGatewayPids();
+    if (stillRunning.length) {
+      api.logger.info(`[moltbank] gateway still running (pids: ${stillRunning.join(' ')}) — sending SIGKILL...`);
+      for (const pid of stillRunning) {
+        try {
+          process.kill(Number(pid), 'SIGKILL');
+        } catch {
+          // ignore
+        }
+      }
       api.logger.info('[moltbank] ✓ gateway process killed');
     } else {
       api.logger.info('[moltbank] ✓ gateway stopped cleanly');
     }
 
-    run('sleep 2', { silent: true });
-
-    const recreate = run('openclaw sandbox recreate --all --force', {
-      silent: false
-    });
-    if (recreate.ok) {
-      api.logger.info('[moltbank] ✓ sandbox containers recreated — new container will be created on next agent message');
-    } else {
-      api.logger.warn('[moltbank] ✗ sandbox recreate failed');
-      api.logger.warn('[moltbank]   run manually: openclaw sandbox recreate --all --force');
-    }
+    setTimeout(() => {
+      const recreate = runCommand('openclaw', ['sandbox', 'recreate', '--all', '--force'], {
+        silent: false
+      });
+      if (recreate.ok) {
+        api.logger.info('[moltbank] ✓ sandbox containers recreated — new container will be created on next agent message');
+      } else {
+        api.logger.warn('[moltbank] ✗ sandbox recreate failed');
+        api.logger.warn('[moltbank]   run manually: openclaw sandbox recreate --all --force');
+      }
 
-    api.logger.info('[moltbank] restarting gateway...');
-    run('openclaw gateway', { silent: true });
+      api.logger.info('[moltbank] restarting gateway...');
+      runCommand('openclaw', ['gateway'], { silent: true });
+    }, 2000);
   }, 8000);
 }
 
+function restartGatewayAfterHostSetup(api: LoggerApi): boolean {
+  api.logger.info('[moltbank] restarting gateway to refresh host skill state...');
+  const restart = runCommand('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 +1904,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,9 +1920,10 @@ 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');
+    const skillInstalled = await ensureSkillInstalled(skillDir, skillBundleBaseUrl, skillName, api, 'sandbox');
     if (!skillInstalled) {
       api.logger.warn('[moltbank] skill install failed — aborting sandbox setup');
       return;
@@ -1521,17 +1975,13 @@ 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');
+    const installed = await 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;
@@ -1568,13 +2018,104 @@ 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 = runCommand('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 = runCommand(
+            '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 = runCommand(join(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] ══════════════════════════════════════`);
@@ -1606,10 +2147,11 @@ export async function runSetup(
       `[moltbank]     setupCommand:         ${finalCmd.includes('node_22.x') && !finalCmd.includes('/home/') ? '✓ ok (no host paths)' : '✗ may be corrupted'}`
     );
 
-    const containerCheck = run(
-      `docker inspect $(docker ps | grep openclaw-sbx | awk '{print $1}') --format '{{.HostConfig.NetworkMode}}' 2>/dev/null`,
-      { silent: true }
-    );
+    const sandboxContainer = runCommand('docker', ['ps', '-q', '--filter', 'name=openclaw-sbx'], { silent: true });
+    const sandboxContainerId = splitNonEmptyLines(sandboxContainer.stdout)[0] || '';
+    const containerCheck = sandboxContainerId
+      ? runCommand('docker', ['inspect', sandboxContainerId, '--format', '{{.HostConfig.NetworkMode}}'], { silent: true })
+      : { ok: false, stdout: '', stderr: '', exitCode: 1, timedOut: false };
     if (!containerCheck.ok || !containerCheck.stdout) {
       api.logger.info(`[moltbank]   container: not running yet — will be created on first agent message`);
     } else if (containerCheck.stdout.trim() === 'bridge') {
@@ -1650,9 +2192,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 +2207,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.11",
     "description": "MoltBank stablecoin treasury CLI and OpenClaw plugin",
     "main": "index.ts",
     "bin": {