openclaw-multi-auto 1.0.9 → 1.1.1

package/scripts/test-shell-completion.ts

@@ -0,0 +1,223 @@
+/**
+ * Test script for shell completion installation feature.
+ *
+ * This script simulates the shell completion prompt that appears during
+ * `openclaw update`. Use it to verify the completion installation flow
+ * without running a full update.
+ *
+ * Run from repo root:
+ *   node --import tsx scripts/test-shell-completion.ts [options]
+ *   npx tsx scripts/test-shell-completion.ts [options]
+ *   bun scripts/test-shell-completion.ts [options]
+ *
+ * Options:
+ *   --shell <shell>   Override shell detection (zsh, bash, fish, powershell)
+ *   --check-only      Only check status, don't prompt to install
+ *   --force           Skip the "already installed" check and prompt anyway
+ *   --help            Show this help message
+ *
+ * Examples:
+ *   node --import tsx scripts/test-shell-completion.ts
+ *   node --import tsx scripts/test-shell-completion.ts --check-only
+ *   node --import tsx scripts/test-shell-completion.ts --shell bash
+ *   node --import tsx scripts/test-shell-completion.ts --force
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { installCompletion } from "../src/cli/completion-cli.js";
+import {
+  checkShellCompletionStatus,
+  ensureCompletionCacheExists,
+} from "../src/commands/doctor-completion.js";
+import { stylePromptMessage } from "../src/terminal/prompt-style.js";
+import { theme } from "../src/terminal/theme.js";
+
+const CLI_NAME = "openclaw";
+
+interface Options {
+  checkOnly: boolean;
+  force: boolean;
+  help: boolean;
+}
+
+function parseArgs(args: string[]): Options {
+  const options: Options = {
+    checkOnly: false,
+    force: false,
+    help: false,
+  };
+
+  for (const arg of args) {
+    if (arg === "--check-only") {
+      options.checkOnly = true;
+    } else if (arg === "--force") {
+      options.force = true;
+    } else if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+function printHelp(): void {
+  console.log(`
+${theme.heading("Shell Completion Test Script")}
+
+This script simulates the shell completion checks that run during
+\`openclaw update\`, \`openclaw doctor\`, and \`openclaw onboard\`.
+
+${theme.heading("Usage (run from repo root):")}
+  node --import tsx scripts/test-shell-completion.ts [options]
+  npx tsx scripts/test-shell-completion.ts [options]
+  bun scripts/test-shell-completion.ts [options]
+
+${theme.heading("Options:")}
+  --check-only      Only check status, don't prompt to install
+  --force           Skip the "already installed" check and prompt anyway
+  --help, -h        Show this help message
+
+${theme.heading("Behavior:")}
+  - If profile has completion but no cache: auto-regenerates cache
+  - If no completion at all: prompts to install
+  - If both profile and cache exist: nothing to do
+
+${theme.heading("Examples:")}
+  node --import tsx scripts/test-shell-completion.ts
+  node --import tsx scripts/test-shell-completion.ts --check-only
+  node --import tsx scripts/test-shell-completion.ts --force
+`);
+}
+
+function getShellProfilePath(shell: string): string {
+  const home = process.env.HOME || os.homedir();
+
+  switch (shell) {
+    case "zsh":
+      return path.join(home, ".zshrc");
+    case "bash":
+      return process.platform === "darwin"
+        ? path.join(home, ".bash_profile")
+        : path.join(home, ".bashrc");
+    case "fish":
+      return path.join(home, ".config", "fish", "config.fish");
+    case "powershell":
+      if (process.platform === "win32") {
+        return path.join(
+          process.env.USERPROFILE || home,
+          "Documents",
+          "PowerShell",
+          "Microsoft.PowerShell_profile.ps1",
+        );
+      }
+      return path.join(home, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+    default:
+      return path.join(home, ".zshrc");
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  console.log(theme.heading("Shell Completion Test"));
+  console.log("");
+
+  // Get completion status using the same function used by doctor/update/onboard
+  const status = await checkShellCompletionStatus(CLI_NAME);
+
+  console.log(`  Shell: ${theme.accent(status.shell)} ${theme.muted("(detected from $SHELL)")}`);
+  console.log(`  Platform: ${theme.muted(process.platform)} ${theme.muted(`(${os.release()})`)}`);
+  console.log(`  Profile: ${theme.muted(getShellProfilePath(status.shell))}`);
+  console.log(`  Cache path: ${theme.muted(status.cachePath)}`);
+  console.log("");
+  console.log(
+    `  Profile configured: ${status.profileInstalled ? theme.success("yes") : theme.warn("no")}`,
+  );
+  console.log(`  Cache exists: ${status.cacheExists ? theme.success("yes") : theme.warn("no")}`);
+  console.log(
+    `  Uses slow pattern: ${status.usesSlowPattern ? theme.error("yes (needs upgrade)") : theme.success("no")}`,
+  );
+  console.log("");
+
+  if (options.checkOnly) {
+    console.log(theme.muted("Check-only mode, exiting."));
+    return;
+  }
+
+  // Profile uses slow dynamic pattern - upgrade to cached version
+  if (status.usesSlowPattern) {
+    console.log(theme.warn("Profile uses slow dynamic completion. Upgrading to cached version..."));
+    const cacheGenerated = await ensureCompletionCacheExists(CLI_NAME);
+    if (cacheGenerated) {
+      await installCompletion(status.shell, false, CLI_NAME);
+      console.log(theme.success("Upgraded to cached completion."));
+    } else {
+      console.log(theme.error("Failed to generate cache."));
+    }
+    return;
+  }
+
+  // Profile has completion but no cache - auto-fix
+  if (status.profileInstalled && !status.cacheExists) {
+    console.log(theme.warn("Profile has completion but cache is missing. Regenerating..."));
+    const cacheGenerated = await ensureCompletionCacheExists(CLI_NAME);
+    if (cacheGenerated) {
+      console.log(theme.success("Cache regenerated successfully."));
+    } else {
+      console.log(theme.error("Failed to regenerate cache."));
+    }
+    return;
+  }
+
+  // Both profile and cache exist - nothing to do
+  if (status.profileInstalled && status.cacheExists && !options.force) {
+    console.log(theme.muted("Shell completion is fully configured. To test the prompt:"));
+    console.log(
+      theme.muted("  1. Remove the '# OpenClaw Completion' block from your shell profile"),
+    );
+    console.log(theme.muted("  2. Re-run this script"));
+    console.log(theme.muted("  Or use --force to prompt anyway"));
+    console.log("");
+    return;
+  }
+
+  // No profile configured - prompt to install
+  console.log(theme.heading("Shell completion"));
+
+  const shouldInstall = await confirm({
+    message: stylePromptMessage(`Enable ${status.shell} shell completion for ${CLI_NAME}?`),
+    initialValue: true,
+  });
+
+  if (isCancel(shouldInstall) || !shouldInstall) {
+    console.log(theme.muted(`Skipped. Run \`openclaw completion --install\` later to enable.`));
+    return;
+  }
+
+  // Generate cache first (required for fast shell startup)
+  if (!status.cacheExists) {
+    console.log(theme.muted("Generating completion cache..."));
+    const cacheGenerated = await ensureCompletionCacheExists(CLI_NAME);
+    if (!cacheGenerated) {
+      console.log(theme.error("Failed to generate completion cache."));
+      return;
+    }
+    console.log(theme.success("Cache generated."));
+  }
+
+  // Install to shell profile
+  await installCompletion(status.shell, false, CLI_NAME);
+}
+
+main().catch((err) => {
+  console.error(theme.error(`Error: ${String(err)}`));
+  process.exit(1);
+});

package/scripts/ui.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, "..");
+const uiDir = path.join(repoRoot, "ui");
+
+const WINDOWS_SHELL_EXTENSIONS = new Set([".cmd", ".bat", ".com"]);
+const WINDOWS_UNSAFE_SHELL_ARG_PATTERN = /[\r\n"&|<>^%!]/;
+
+function usage() {
+  // keep this tiny; it's invoked from npm scripts too
+  process.stderr.write("Usage: node scripts/ui.js <install|dev|build|test> [...args]\n");
+}
+
+function which(cmd) {
+  try {
+    const key = process.platform === "win32" ? "Path" : "PATH";
+    const paths = (process.env[key] ?? process.env.PATH ?? "")
+      .split(path.delimiter)
+      .filter(Boolean);
+    const extensions =
+      process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)
+        : [""];
+    for (const entry of paths) {
+      for (const ext of extensions) {
+        const candidate = path.join(entry, process.platform === "win32" ? `${cmd}${ext}` : cmd);
+        try {
+          if (fs.existsSync(candidate)) {
+            return candidate;
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+function resolveRunner() {
+  const pnpm = which("pnpm");
+  if (pnpm) {
+    return { cmd: pnpm, kind: "pnpm" };
+  }
+  return null;
+}
+
+export function shouldUseShellForCommand(cmd, platform = process.platform) {
+  if (platform !== "win32") {
+    return false;
+  }
+  const extension = path.extname(cmd).toLowerCase();
+  return WINDOWS_SHELL_EXTENSIONS.has(extension);
+}
+
+export function assertSafeWindowsShellArgs(args, platform = process.platform) {
+  if (platform !== "win32") {
+    return;
+  }
+  const unsafeArg = args.find((arg) => WINDOWS_UNSAFE_SHELL_ARG_PATTERN.test(arg));
+  if (!unsafeArg) {
+    return;
+  }
+  // SECURITY: `shell: true` routes through cmd.exe; reject risky metacharacters
+  // in forwarded args to prevent shell control-flow/env-expansion injection.
+  throw new Error(
+    `Unsafe Windows shell argument: ${unsafeArg}. Remove shell metacharacters (" & | < > ^ % !).`,
+  );
+}
+
+function createSpawnOptions(cmd, args, envOverride) {
+  const useShell = shouldUseShellForCommand(cmd);
+  if (useShell) {
+    assertSafeWindowsShellArgs(args);
+  }
+  return {
+    cwd: uiDir,
+    stdio: "inherit",
+    env: envOverride ?? process.env,
+    ...(useShell ? { shell: true } : {}),
+  };
+}
+
+function run(cmd, args) {
+  let child;
+  try {
+    child = spawn(cmd, args, createSpawnOptions(cmd, args));
+  } catch (err) {
+    console.error(`Failed to launch ${cmd}:`, err);
+    process.exit(1);
+    return;
+  }
+
+  child.on("error", (err) => {
+    console.error(`Failed to launch ${cmd}:`, err);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    if (code !== 0) {
+      process.exit(code ?? 1);
+    }
+  });
+}
+
+function runSync(cmd, args, envOverride) {
+  let result;
+  try {
+    result = spawnSync(cmd, args, createSpawnOptions(cmd, args, envOverride));
+  } catch (err) {
+    console.error(`Failed to launch ${cmd}:`, err);
+    process.exit(1);
+    return;
+  }
+  if (result.signal) {
+    process.exit(1);
+  }
+  if ((result.status ?? 1) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+function depsInstalled(kind) {
+  try {
+    const require = createRequire(path.join(uiDir, "package.json"));
+    require.resolve("vite");
+    require.resolve("dompurify");
+    if (kind === "test") {
+      require.resolve("vitest");
+      require.resolve("@vitest/browser-playwright");
+      require.resolve("playwright");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveScriptAction(action) {
+  if (action === "install") {
+    return null;
+  }
+  if (action === "dev") {
+    return "dev";
+  }
+  if (action === "build") {
+    return "build";
+  }
+  if (action === "test") {
+    return "test";
+  }
+  return null;
+}
+
+export function main(argv = process.argv.slice(2)) {
+  const [action, ...rest] = argv;
+  if (!action) {
+    usage();
+    process.exit(2);
+  }
+
+  const runner = resolveRunner();
+  if (!runner) {
+    process.stderr.write("Missing UI runner: install pnpm, then retry.\n");
+    process.exit(1);
+  }
+
+  const script = resolveScriptAction(action);
+  if (action !== "install" && !script) {
+    usage();
+    process.exit(2);
+  }
+
+  if (action === "install") {
+    run(runner.cmd, ["install", ...rest]);
+    return;
+  }
+
+  if (!depsInstalled(action === "test" ? "test" : "build")) {
+    const installEnv =
+      action === "build" ? { ...process.env, NODE_ENV: "production" } : process.env;
+    const installArgs = action === "build" ? ["install", "--prod"] : ["install"];
+    runSync(runner.cmd, installArgs, installEnv);
+  }
+
+  run(runner.cmd, ["run", script, ...rest]);
+}
+
+const isDirectExecution = (() => {
+  const entry = process.argv[1];
+  return Boolean(entry && path.resolve(entry) === fileURLToPath(import.meta.url));
+})();
+
+if (isDirectExecution) {
+  main();
+}