msdevflow 0.7.1 → 0.7.3

package/lib/bootstrap.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import {
   closeSync,
@@ -265,6 +265,22 @@ function executableCommand(executable, args, platform) {
   };
 }
 
+export function interactiveExecutableCommand(executable, args, platform) {
+  if (platform !== "win32" || !/\.(?:cmd|bat)$/i.test(executable)) {
+    return executableCommand(executable, args, platform);
+  }
+  const values = [executable, ...args];
+  if (values.some((value) => /["\r\n]/.test(value))) {
+    throw new BootstrapError("Interactive Windows command contains unsupported characters.", 3);
+  }
+  const commandLine = `"${values.map((value) => `"${value}"`).join(" ")}"`;
+  return {
+    command: "cmd.exe",
+    args: ["/d", "/s", "/c", commandLine],
+    windowsVerbatimArguments: true,
+  };
+}
+
 export function formatCommand(invocation) {
   return [invocation.command, ...invocation.args]
     .map((value) => (/^[A-Za-z0-9_./:@=\\-]+$/.test(value) ? value : JSON.stringify(value)))
@@ -279,6 +295,7 @@ function execute(invocation, { allowFailure = false, inherit = false, outputToSt
       : "pipe",
     maxBuffer: 20 * 1024 * 1024,
     windowsHide: false,
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments === true,
   });
   if (result.error) {
     throw new BootstrapError(`Failed to run ${invocation.command}: ${result.error.message}`);
@@ -295,6 +312,54 @@ function execute(invocation, { allowFailure = false, inherit = false, outputToSt
   };
 }
 
+function executeAsync(invocation, { allowFailure = false, inherit = false, outputToStderr = false } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(invocation.command, invocation.args, {
+      stdio: inherit
+        ? ["inherit", outputToStderr ? process.stderr : "inherit", "inherit"]
+        : ["ignore", "pipe", "pipe"],
+      windowsHide: false,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments === true,
+    });
+    const stdout = [];
+    const stderr = [];
+    let outputBytes = 0;
+    let outputError = null;
+    const capture = (chunks) => (chunk) => {
+      outputBytes += chunk.length;
+      if (outputBytes > 20 * 1024 * 1024) {
+        outputError = new BootstrapError(`Command output exceeded 20 MiB: ${formatCommand(invocation)}`);
+        child.kill();
+        return;
+      }
+      chunks.push(chunk);
+    };
+    child.stdout?.on("data", capture(stdout));
+    child.stderr?.on("data", capture(stderr));
+    child.once("error", (error) => {
+      reject(new BootstrapError(`Failed to run ${invocation.command}: ${error.message}`));
+    });
+    child.once("close", (code) => {
+      if (outputError) {
+        reject(outputError);
+        return;
+      }
+      const status = code ?? 1;
+      const result = {
+        status,
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+      };
+      if (status !== 0 && !allowFailure) {
+        const detail = inherit ? "" : `\n${(result.stderr || result.stdout).trim()}`;
+        reject(new BootstrapError(`Command failed (${status}): ${formatCommand(invocation)}${detail}`));
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
 function runOptional(run, invocation) {
   try {
     return run(invocation, { allowFailure: true });
@@ -306,6 +371,55 @@ function runOptional(run, invocation) {
   }
 }
 
+async function runOptionalAsync(run, invocation) {
+  try {
+    return await run(invocation, { allowFailure: true });
+  } catch (error) {
+    if (error instanceof BootstrapError && error.message.startsWith("Failed to run ")) {
+      return { status: 1, stdout: "", stderr: error.message };
+    }
+    throw error;
+  }
+}
+
+export function createProgress(output, writeLine, timers = { setInterval, clearInterval }) {
+  const interactive = Boolean(output?.isTTY && typeof output.write === "function");
+  const frames = ["|", "/", "-", "\\"];
+  return {
+    async run(label, operation) {
+      if (!interactive) {
+        writeLine(`${label}...`);
+        try {
+          const result = await operation();
+          writeLine(`${label}: done`);
+          return result;
+        } catch (error) {
+          writeLine(`${label}: failed`);
+          throw error;
+        }
+      }
+
+      let frame = 0;
+      const render = () => {
+        output.write(`\r${frames[frame]} ${label}`);
+        frame = (frame + 1) % frames.length;
+      };
+      render();
+      const timer = timers.setInterval(render, 80);
+      try {
+        const result = await operation();
+        timers.clearInterval(timer);
+        output.write(`\r[done] ${label}\n`);
+        return result;
+      } catch (error) {
+        timers.clearInterval(timer);
+        output.write(`\r[failed] ${label}\n`);
+        throw error;
+      }
+    },
+  };
+}
+
 function verifyFile(file, missingMessage) {
   let descriptor;
   try {
@@ -481,8 +595,8 @@ function validatePythonRequirements(file) {
   }
 }
 
-function firstOutputLine(output) {
-  return output.split(/\r?\n/).map((line) => line.trim()).find(Boolean) || "";
+function outputLines(output) {
+  return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
 }
 
 export function resolveExecutable(name, run, platform) {
@@ -490,7 +604,14 @@ export function resolveExecutable(name, run, platform) {
     ? { command: "where.exe", args: [name] }
     : { command: "sh", args: ["-c", "command -v -- \"$1\"", "sh", name] };
   const result = runOptional(run, invocation);
-  return result.status === 0 ? firstOutputLine(result.stdout) : "";
+  if (result.status !== 0) {
+    return "";
+  }
+  const candidates = outputLines(result.stdout);
+  if (platform === "win32") {
+    return candidates.find((candidate) => /\.(?:com|exe|cmd|bat|ps1)$/i.test(candidate)) || "";
+  }
+  return candidates[0] || "";
 }
 
 export function detectClients(run, platform) {
@@ -785,8 +906,8 @@ function writeWrapper(details, platform) {
   }
 }
 
-function installGitcode(plan, run, platform) {
-  run(plan.installInvocation);
+async function installGitcode(plan, runLong, run, platform) {
+  await runLong(plan.installInvocation);
   if (plan.gitcodeInstall.mode === "coexist") {
     verifyFile(
       plan.gitcodeInstall.cliTarget,
@@ -878,10 +999,10 @@ function cliInvoker(cliExecutable, run, platform) {
   return (args, options) => run(executableCommand(cliExecutable, args, platform), options);
 }
 
-function validateCore(cliExecutable, run, platform) {
+async function validateCore(cliExecutable, run, platform) {
   const invoke = cliInvoker(cliExecutable, run, platform);
-  const version = invoke(["version"]).stdout.trim();
-  const doctor = invoke(["doctor", "install", "--json"], { allowFailure: true });
+  const version = (await invoke(["version"])).stdout.trim();
+  const doctor = await invoke(["doctor", "install", "--json"], { allowFailure: true });
   const missing = [];
   try {
     const metadata = JSON.parse(doctor.stdout);
@@ -892,7 +1013,7 @@ function validateCore(cliExecutable, run, platform) {
     missing.push("doctor install (invalid JSON)");
   }
   for (const [schema, requiredFlags] of Object.entries(REQUIRED_SCHEMAS)) {
-    const result = invoke(["schema", schema], { allowFailure: true });
+    const result = await invoke(["schema", schema], { allowFailure: true });
     if (result.status !== 0) {
       missing.push(schema);
       continue;
@@ -909,28 +1030,45 @@ function validateCore(cliExecutable, run, platform) {
       missing.push(`${schema} (invalid schema JSON)`);
     }
   }
-  if (invoke(["api", "--help"], { allowFailure: true }).status !== 0) {
+  if ((await invoke(["api", "--help"], { allowFailure: true })).status !== 0) {
     missing.push("api");
   }
   if (missing.length) {
     throw new BootstrapError(`GitCode CLI is missing required capabilities: ${missing.join(", ")}.`);
   }
-  const authentication = safeAuthStatus(invoke(["auth", "status", "--json"], { allowFailure: true }).stdout);
+  const authentication = safeAuthStatus(
+    (await invoke(["auth", "status", "--json"], { allowFailure: true })).stdout,
+  );
   return { version, authentication, capabilities: "passed" };
 }
 
-function authenticateGitcode(cliExecutable, authentication, run, platform, write, jsonOutput) {
+async function authenticateGitcode(
+  cliExecutable,
+  authentication,
+  runInteractive,
+  runLong,
+  platform,
+  write,
+  progress,
+  jsonOutput,
+) {
   if (authentication.logged_in) {
     return authentication;
   }
-  const invoke = cliInvoker(cliExecutable, run, platform);
+  const invokeLong = cliInvoker(cliExecutable, runLong, platform);
   write("GitCode authentication is required. Opening the official browser login.");
-  write("Complete the GitCode page shown by the CLI; do not paste a token into this terminal or the conversation.");
-  invoke(["auth", "login", "--web"], {
-    inherit: true,
-    outputToStderr: jsonOutput,
-  });
-  authentication = safeAuthStatus(invoke(["auth", "status", "--json"], { allowFailure: true }).stdout);
+  write("Create the token in the browser, paste it at the CLI prompt, then press Enter.");
+  write("Waiting for the GitCode CLI login process to finish; token verification can take up to 30 seconds.");
+  await runInteractive(
+    interactiveExecutableCommand(cliExecutable, ["auth", "login", "--web"], platform),
+    {
+      inherit: true,
+      outputToStderr: jsonOutput,
+    },
+  );
+  authentication = await progress.run("Verifying GitCode authentication", async () => safeAuthStatus(
+    (await invokeLong(["auth", "status", "--json"], { allowFailure: true })).stdout,
+  ));
   if (!authentication.logged_in) {
     throw new BootstrapError("GitCode browser login did not produce an authenticated CLI session.", 2);
   }
@@ -962,8 +1100,16 @@ export async function runSetup(options, dependencies = {}) {
   const platform = dependencies.platform || process.platform;
   const environment = dependencies.environment || process.env;
   const run = dependencies.run || execute;
+  const runLong = dependencies.runLong || dependencies.run || executeAsync;
+  const runInteractive = dependencies.runInteractive || dependencies.run || executeAsync;
   const write = dependencies.write || ((line) => console.log(line));
   const writePlan = dependencies.writePlan || write;
+  const writeProgress = options.json ? writePlan : write;
+  const progress = dependencies.progress || createProgress(
+    dependencies.progressOutput || (options.json ? process.stderr : process.stdout),
+    writeProgress,
+    dependencies.timers,
+  );
   const targetSelection = await resolveClientTargets(
     options,
     run,
@@ -996,11 +1142,14 @@ export async function runSetup(options, dependencies = {}) {
   run(namedCommand("npm", ["--version"], platform));
   const npmPrefix = run(namedCommand("npm", ["config", "get", "prefix"], platform)).stdout.trim();
   const gitVersion = run(namedCommand("git", ["--version"], platform)).stdout.trim();
-  const latestResult = runOptional(run, namedCommand(
-    "npm",
-    ["view", "@gitcode-cli/cli", "version", `--registry=${REGISTRY}`],
-    platform,
-  ));
+  const latestResult = await progress.run(
+    "Checking the latest GitCode CLI version",
+    () => runOptionalAsync(runLong, namedCommand(
+      "npm",
+      ["view", "@gitcode-cli/cli", "version", `--registry=${REGISTRY}`],
+      platform,
+    )),
+  );
   const diagnosis = diagnoseGitcode(run, platform);
   diagnosis.officialLatest = latestResult.status === 0 ? latestResult.stdout.trim() || null : null;
   const gitcodeInstall = gitcodeInstallDetails(diagnosis.classification, environment, platform, npmPrefix);
@@ -1045,27 +1194,40 @@ export async function runSetup(options, dependencies = {}) {
     validateWrapper(gitcodeInstall, platform);
   }
 
-  const installed = installGitcode(plan, run, platform);
-  const gitcode = validateCore(installed.executable, run, platform);
+  const installed = await progress.run(
+    "Installing the official GitCode CLI",
+    () => installGitcode(plan, runLong, run, platform),
+  );
+  const gitcode = await progress.run(
+    "Validating GitCode CLI capabilities",
+    () => validateCore(installed.executable, runLong, platform),
+  );
   gitcode.command = installed.command;
   gitcode.executable = installed.executable;
 
-  run(pipInvocation);
-  run({ command: python.executable, args: ["-c", "import playwright.sync_api"] });
-  gitcode.authentication = authenticateGitcode(
+  await progress.run("Installing reviewed Python dependencies", () => runLong(pipInvocation));
+  await progress.run(
+    "Verifying the Playwright Python package",
+    () => runLong({ command: python.executable, args: ["-c", "import playwright.sync_api"] }),
+  );
+  gitcode.authentication = await authenticateGitcode(
     installed.executable,
     gitcode.authentication,
-    run,
+    runInteractive,
+    runLong,
     platform,
-    options.json ? writePlan : write,
+    writeProgress,
+    progress,
     options.json,
   );
-  const skills = skillInstalls.map(({ layout, details }) => ({
-    kind: layout.kind,
-    clients: layout.clients,
-    status: installBundledSkill(details),
-    target: layout.workflowDir,
-  }));
+  const skills = await progress.run("Installing msdevflow skill targets", async () => (
+    skillInstalls.map(({ layout, details }) => ({
+      kind: layout.kind,
+      clients: layout.clients,
+      status: installBundledSkill(details),
+      target: layout.workflowDir,
+    }))
+  ));
   const result = {
     state: "ready",
     git: gitVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msdevflow",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Install the msdevflow GitCode skill and its runtime dependencies",
   "type": "module",
   "bin": {