@moltbankhq/openclaw 0.1.11 → 0.1.12

package/index.ts

@@ -365,10 +365,136 @@ function getExecErrorMessage(error: unknown): string {
   return String(error);
 }
 
+function getPathEnvKey(env: NodeJS.ProcessEnv): string {
+  const existing = Object.keys(env).find((key) => key.toLowerCase() === 'path');
+  return existing ?? 'Path';
+}
+
+function splitPathEntries(value: string): string[] {
+  return value
+    .split(IS_WIN ? ';' : ':')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function prependPathEntries(env: NodeJS.ProcessEnv, entries: string[]): void {
+  if (entries.length === 0) return;
+
+  const pathKey = getPathEnvKey(env);
+  const existing = splitPathEntries(asString(env[pathKey]));
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+
+  for (const entry of [...entries, ...existing]) {
+    const normalized = IS_WIN ? entry.toLowerCase() : entry;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    ordered.push(entry);
+  }
+
+  env[pathKey] = ordered.join(IS_WIN ? ';' : ':');
+}
+
+function isExplicitCommandPath(command: string): boolean {
+  return command.includes('/') || command.includes('\\') || /^[A-Za-z]:/.test(command);
+}
+
+function getWindowsCommandExtensions(env: NodeJS.ProcessEnv): string[] {
+  const fromEnv = asString(env.PATHEXT || process.env.PATHEXT)
+    .split(';')
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+
+  const preferred = ['.exe', '.com', '.ps1', '.cmd', '.bat'];
+  const out: string[] = [];
+  for (const ext of [...preferred, ...fromEnv]) {
+    const normalized = ext.startsWith('.') ? ext : `.${ext}`;
+    if (!out.includes(normalized)) {
+      out.push(normalized);
+    }
+  }
+  return out;
+}
+
+function resolveWindowsCommandPath(command: string, env: NodeJS.ProcessEnv): string {
+  const extensions = getWindowsCommandExtensions(env);
+
+  const tryCandidates = (basePath: string): string => {
+    if (existsSync(basePath)) return basePath;
+
+    const lower = basePath.toLowerCase();
+    for (const ext of extensions) {
+      if (lower.endsWith(ext)) continue;
+      const candidate = `${basePath}${ext}`;
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+
+    return '';
+  };
+
+  if (isExplicitCommandPath(command)) {
+    return tryCandidates(command);
+  }
+
+  const pathValue = asString(env[getPathEnvKey(env)]);
+  for (const entry of splitPathEntries(pathValue)) {
+    const resolved = tryCandidates(join(entry, command));
+    if (resolved) {
+      return resolved;
+    }
+  }
+
+  return '';
+}
+
+function quoteCmdArgument(value: string): string {
+  if (!value) return '""';
+
+  const escaped = value
+    .replace(/([()%!^"<>&|])/g, '^$1')
+    .replace(/\r/g, ' ')
+    .replace(/\n/g, ' ');
+
+  return /[\s()%!^"<>&|]/.test(value) ? `"${escaped}"` : escaped;
+}
+
+function prepareCommandForSpawn(command: string, args: string[], env: NodeJS.ProcessEnv): { command: string; args: string[] } {
+  if (!IS_WIN) {
+    return { command, args };
+  }
+
+  const resolved = resolveWindowsCommandPath(command, env);
+  if (!resolved) {
+    return { command, args };
+  }
+
+  const lower = resolved.toLowerCase();
+  if (lower.endsWith('.ps1')) {
+    return {
+      command: 'powershell.exe',
+      args: ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', resolved, ...args]
+    };
+  }
+
+  if (lower.endsWith('.cmd') || lower.endsWith('.bat')) {
+    const cmdExe = asString(env.ComSpec || env.COMSPEC, 'cmd.exe');
+    const commandLine = [resolved, ...args].map((value) => quoteCmdArgument(value)).join(' ');
+    return {
+      command: cmdExe,
+      args: ['/d', '/s', '/c', commandLine]
+    };
+  }
+
+  return { command: resolved, args };
+}
+
 function runCommand(command: string, args: string[], opts: RunOptions = {}): RunResult {
   try {
     const mergedEnv: NodeJS.ProcessEnv = { ...process.env, ...(opts.env ?? {}) };
-    const result = spawnSync(command, args, {
+    const prepared = prepareCommandForSpawn(command, args, mergedEnv);
+    const result = spawnSync(prepared.command, prepared.args, {
       cwd: opts.cwd,
       env: mergedEnv,
       encoding: 'utf8',
@@ -563,6 +689,122 @@ function applyRecursiveMode(rootDir: string, mode: number): void {
   });
 }
 
+function applyRecursiveModes(rootDir: string, dirMode: number, fileMode: number): void {
+  try {
+    chmodSync(rootDir, dirMode);
+  } catch {
+    // ignore
+  }
+
+  visitFiles(rootDir, (fullPath, entry) => {
+    try {
+      chmodSync(fullPath, entry.isDirectory() ? dirMode : fileMode);
+    } catch {
+      // ignore
+    }
+  });
+}
+
+type CommandSpec = {
+  command: string;
+  args: string[];
+  env?: Record<string, string | undefined>;
+};
+
+function withOptionalSudo(command: string, args: string[], env?: Record<string, string | undefined>): CommandSpec {
+  const isRoot = typeof process.getuid === 'function' ? process.getuid() === 0 : false;
+  if (isRoot || !hasBin('sudo')) {
+    return { command, args, env };
+  }
+  return { command: 'sudo', args: [command, ...args], env };
+}
+
+function getUnixJqInstallPlan(): { name: string; steps: CommandSpec[] } | null {
+  if (hasBin('apt-get')) {
+    return {
+      name: 'apt-get',
+      steps: [
+        withOptionalSudo('apt-get', ['update', '-qq'], { DEBIAN_FRONTEND: 'noninteractive' }),
+        withOptionalSudo('apt-get', ['install', '-y', 'jq'], { DEBIAN_FRONTEND: 'noninteractive' })
+      ]
+    };
+  }
+
+  if (hasBin('dnf')) {
+    return {
+      name: 'dnf',
+      steps: [withOptionalSudo('dnf', ['install', '-y', 'jq'])]
+    };
+  }
+
+  if (hasBin('yum')) {
+    return {
+      name: 'yum',
+      steps: [withOptionalSudo('yum', ['install', '-y', 'jq'])]
+    };
+  }
+
+  if (hasBin('pacman')) {
+    return {
+      name: 'pacman',
+      steps: [withOptionalSudo('pacman', ['-Sy', '--noconfirm', 'jq'])]
+    };
+  }
+
+  if (hasBin('apk')) {
+    return {
+      name: 'apk',
+      steps: [withOptionalSudo('apk', ['add', 'jq'])]
+    };
+  }
+
+  if (hasBin('zypper')) {
+    return {
+      name: 'zypper',
+      steps: [withOptionalSudo('zypper', ['install', '-y', 'jq'])]
+    };
+  }
+
+  if (hasBin('brew')) {
+    return {
+      name: 'brew',
+      steps: [{ command: 'brew', args: ['install', 'jq'] }]
+    };
+  }
+
+  return null;
+}
+
+function ensureUnixJq(api: LoggerApi): boolean {
+  const plan = getUnixJqInstallPlan();
+  if (!plan) {
+    return false;
+  }
+
+  api.logger.info(`[moltbank] jq not found — attempting install via ${plan.name}...`);
+
+  for (const step of plan.steps) {
+    const result = runCommand(step.command, step.args, {
+      env: step.env,
+      timeoutMs: 180000
+    });
+
+    if (!result.ok) {
+      api.logger.warn(`[moltbank] jq install via ${plan.name} failed: ${result.stderr}`);
+      return false;
+    }
+  }
+
+  if (!hasBin('jq')) {
+    api.logger.warn(`[moltbank] jq install via ${plan.name} finished, but jq is still not visible in PATH`);
+    return false;
+  }
+
+  const version = runCommand('jq', ['--version'], { silent: true });
+  api.logger.info(`[moltbank] ✓ jq installed via ${plan.name} (${version.stdout || 'unknown version'})`);
+  return true;
+}
+
 function findWindowsJqBinaryPath(): string {
   if (!IS_WIN) return '';
 
@@ -652,6 +894,7 @@ function ensureWindowsJqShim(api: LoggerApi): boolean {
       const shimBody = `@echo off\r\n"${escapedSource}" %*\r\n`;
       writeFileSync(shimPath, shimBody, 'utf8');
     }
+    prependPathEntries(process.env, [npmBinDir]);
   } catch (e) {
     api.logger.warn('[moltbank] could not create jq shim in npm global bin: ' + String(e));
     return false;
@@ -816,6 +1059,10 @@ function ensureJq(api: LoggerApi) {
   }
 
   if (!IS_WIN) {
+    if (ensureUnixJq(api)) {
+      return;
+    }
+
     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;
@@ -1111,20 +1358,20 @@ function ensureSkillPermissions(skillDir: string, api: LoggerApi) {
   }
 
   if (existsSync(assetsDir)) {
-    applyRecursiveMode(assetsDir, 0o777);
-    api.logger.info('[moltbank] ✓ assets/ permissions → 777');
+    applyRecursiveModes(assetsDir, 0o750, 0o640);
+    api.logger.info('[moltbank] ✓ assets/ permissions → 750 dirs, 640 files');
   }
   if (existsSync(configFile)) {
     try {
-      chmodSync(configFile, 0o666);
+      chmodSync(configFile, 0o600);
     } catch {
       // ignore
     }
-    api.logger.info('[moltbank] ✓ mcporter.json permissions → 666');
+    api.logger.info('[moltbank] ✓ mcporter.json permissions → 600');
   }
   if (existsSync(scriptsDir)) {
-    applyRecursiveMode(scriptsDir, 0o755);
-    api.logger.info('[moltbank] ✓ scripts/ permissions → 755');
+    applyRecursiveModes(scriptsDir, 0o750, 0o750);
+    api.logger.info('[moltbank] ✓ scripts/ permissions → 750');
     normalizeFilesMatching(scriptsDir, () => true);
     api.logger.info('[moltbank] ✓ scripts/ line endings normalized (CRLF → LF)');
   }

package/package.json

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