mason-context 0.17.1 → 0.17.2

package/dist/mason.js

@@ -2996,7 +2996,7 @@ var init_evidence = __esm({
     init_storage();
     init_advisory_review();
     exec7 = promisify9(execFile9);
-    engineVersion = true ? "0.17.1" : "development";
+    engineVersion = true ? "0.17.2" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     cacheSchema = z8.object({ version: z8.literal(1), entries: z8.record(z8.object({ key: z8.string(), result: checkResultSchema })), digest: z8.string() });
@@ -3650,7 +3650,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.17.1" : "development";
+    executingVersion = () => true ? "0.17.2" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -5491,6 +5491,7 @@ async function selectHost(root, explicit) {
   throw new Error("Choose the assistant for setup with --host codex or --host claude.");
 }
 async function setupProject(dir, options = {}) {
+  options.progress?.step("Checking project configuration");
   const ws = await workspace(dir);
   const host = await selectHost(ws.root, options.host);
   return withLock(ws.root, ".mason/reports/setup-lock", async () => {
@@ -5519,11 +5520,14 @@ async function setupProject(dir, options = {}) {
     const revision = !changed && previous ? previous.revision : randomUUID6();
     const setup = existing ?? { version: 2, hosts: {} };
     setup.hosts[host] = { configuredVersion: installed.version, revision, fingerprint, mcpFingerprint, instructions: instructions.map((e) => e.path) };
+    options.progress?.step("Auditing documentation and preserving original findings");
     const initial = await automate(ws.root, { event: "turn_start" });
+    options.progress?.step("Reviewing project context and committed changes");
     const findings = await inspectOnboarding(ws.root, options.base, options.evidence);
     const receiptPath = ws.directory + "/setup-" + host + ".json";
     const initialReportPath = previousReceipt?.initialReportPath ?? initial.report.reportPath;
     const initialBaselinePaths = previousReceipt?.initialBaselinePaths ?? initial.report.baselinePaths;
+    options.progress?.step(`Configuring ${host === "codex" ? "Codex" : "Claude Code"} integration`);
     await writeStoreJson(ws.root, receiptPath, {
       version: 1,
       host,
@@ -5538,6 +5542,7 @@ async function setupProject(dir, options = {}) {
     for (const edit of edits) if (await applyEdit(ws.root, edit)) changedFiles.push(edit.path);
     if (await applyEdit(ws.root, { path: SETUP_PATH, before: setupBefore, after: JSON.stringify(setup, null, 2) + "\n" })) changedFiles.push(SETUP_PATH);
     if (await applyEdit(ws.root, await completedHookOwnership(ws.root, hooks[0].path, configuredHook)) && !changedFiles.includes(ownership.path)) changedFiles.push(ownership.path);
+    options.progress?.step("Checking configuration and retained findings");
     const checked = await automate(ws.root, { event: "turn_start" });
     const configured = await inspectHostConfig(ws.root, host, void 0);
     await writeStoreJson(ws.root, receiptPath, {
@@ -5660,9 +5665,11 @@ async function configurePath(bin, previous, save, options = {}) {
   const changes = [...previous];
   const currentPath = platform === "win32" ? Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] : env.PATH;
   const alreadyOnPath = platform === "win32" ? hasWindowsEntry(currentPath ?? null, bin, env) : (currentPath ?? "").split(":").some((entry) => path26.posix.isAbsolute(entry) && path26.posix.resolve(entry) === path26.posix.resolve(bin));
-  const message2 = alreadyOnPath ? "Run: mason setup --host codex" : "Open a new terminal, then run: mason setup --host codex";
+  const setupHint = "To connect a project, run one of these inside its directory:\n  Codex:       mason setup --host codex\n  Claude Code: mason setup --host claude";
+  const message2 = (alreadyOnPath ? "" : "Open a new terminal to use mason.\n") + setupHint;
   const manual = (reason2) => ({ status: "manual", changes, message: `${reason2}
-${alreadyOnPath ? message2 : `Add ${bin} to your PATH, then run: mason setup --host codex`}` });
+${alreadyOnPath ? "" : `Add ${bin} to your PATH.
+`}${setupHint}` });
   if (env.MASON_NO_MODIFY_PATH === "1") return manual("Automatic PATH setup is disabled (MASON_NO_MODIFY_PATH=1).");
   if (/[\r\n\0]/.test(bin) || bin.includes(platform === "win32" ? ";" : ":")) return manual("This installation path cannot be represented safely in PATH.");
   try {
@@ -5853,7 +5860,8 @@ async function replace(file, content2, mode = 384) {
     await fs22.rm(temp, { force: true });
   }
 }
-async function installStandalone(source) {
+async function installStandalone(source, progress2) {
+  progress2?.step("Checking installation files and location");
   const bundle = await verifyBundle(source);
   const selectedHome = path27.resolve(defaultHome());
   await fs22.mkdir(selectedHome, { recursive: true });
@@ -5914,6 +5922,7 @@ exec ${shQuote(path27.join(destination, "node"))} ${shQuote(path27.join(destinat
       if (actual !== null && actual !== expected) throw new Error("Retired launcher was edited; retained: " + name);
     };
     for (const [name, expected] of retired) await checkRetired(name, expected);
+    progress2?.step(`Installing Mason ${bundle.manifest.version}`);
     const receipt = { format: 1, home, bin, current: id, version: bundle.manifest.version, launchers, pathChanges: previous?.pathChanges ?? [] };
     await writeStoreJson(home, "install.json", { ...receipt, previousLaunchers: previous?.previousLaunchers ?? previous?.launchers });
     const stage = await storePath(home, "versions/.install-" + randomUUID8(), true);
@@ -5940,11 +5949,12 @@ exec ${shQuote(path27.join(destination, "node"))} ${shQuote(path27.join(destinat
     } finally {
       await fs22.rm(stage, { recursive: true, force: true });
     }
+    progress2?.step("Checking terminal command availability");
     const pathResult = await configurePath(bin, receipt.pathChanges, async (changes) => {
       receipt.pathChanges = changes;
       await writeStoreJson(home, "install.json", receipt);
     });
-    return { home, bin, version: bundle.manifest.version, path: pathResult };
+    return { home, bin, version: bundle.manifest.version, previousVersion: previous?.version, path: pathResult };
   });
 }
 async function currentInstallation() {
@@ -5956,12 +5966,14 @@ async function currentInstallation() {
   if (record.home !== await fs22.realpath(home) || path27.dirname(bundle) !== path27.join(home, "versions")) throw new Error("Invalid standalone installation receipt.");
   return { home, bundle, record };
 }
-async function upgradeStandalone(version) {
+async function upgradeStandalone(version, progress2) {
   if (version && !/^v?\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(version)) throw new Error("Expected a release version such as 0.14.0.");
+  progress2?.step("Checking current installation");
   const { home, bundle, record } = await currentInstallation();
   await verifyBundle(bundle);
   const windows = process.platform === "win32";
   const script = path27.join(bundle, windows ? "install.ps1" : "install.sh");
+  progress2?.stop();
   return new Promise((resolve, reject) => {
     const child = spawn(
       windows ? "powershell.exe" : "sh",
@@ -6031,6 +6043,57 @@ init_adapters();
 init_install();
 init_store();
 import { parseArgs } from "util";
+
+// src/utils/progress.ts
+function createProgress(options = {}) {
+  const write = options.write ?? ((text2) => {
+    process.stderr.write(text2);
+  });
+  const interactive = options.interactive ?? (!!process.stderr.isTTY && process.env.TERM !== "dumb" && !process.env.CI);
+  const columns = options.columns ?? (() => process.stderr.columns || 80);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let message2 = "", started = 0, frame = 0;
+  let timer;
+  const elapsed = () => {
+    const seconds = Math.floor((Date.now() - started) / 1e3);
+    return seconds ? ` (${seconds}s)` : "";
+  };
+  const render = (prefix) => {
+    const text2 = `${prefix} ${message2}${elapsed()}`;
+    const width = Math.max(1, columns() - 1);
+    write("\r\x1B[2K" + (text2.length > width ? text2.slice(0, width - 1) + "\u2026" : text2));
+  };
+  const stop = (success = true) => {
+    if (timer) clearInterval(timer);
+    timer = void 0;
+    if (message2 && interactive) {
+      render(success ? "\u2713" : "\u2717");
+      write("\n");
+    }
+    message2 = "";
+  };
+  return {
+    step(next) {
+      stop();
+      message2 = next.replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
+      started = Date.now();
+      frame = 0;
+      if (!interactive) {
+        write(`Mason: ${message2}\u2026
+`);
+        return;
+      }
+      render(frames[frame]);
+      timer = setInterval(() => {
+        render(frames[++frame % frames.length]);
+      }, 100);
+      timer.unref();
+    },
+    stop
+  };
+}
+
+// src/automation/cli.ts
 var TEARDOWN_USAGE = `Usage: mason teardown [options]
 
 Disconnect Mason from this Git project. Defaults to all project hosts.
@@ -6079,11 +6142,13 @@ function isHookCommand(argv) {
     return false;
   }
 }
-async function runAutomationCli(argv, stdin = "", io = {
+var defaultIo = {
   out: (s) => process.stdout.write(s + "\n"),
   err: (s) => process.stderr.write(s + "\n")
-}, options = {}) {
+};
+async function runAutomationCli(argv, stdin = "", io = defaultIo, options = {}) {
   let action = "";
+  let progress2;
   try {
     const { values, positionals } = parseCli(argv);
     if (values.help || !positionals.length) {
@@ -6111,7 +6176,13 @@ async function runAutomationCli(argv, stdin = "", io = {
     if (action === "setup") {
       if (values.command) throw new Error("--command applies to install/config, not managed setup.");
       const { setupProject: setupProject2, summarizeSetup: summarizeSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
-      const result = await setupProject2(dir, { host: values.host ? hostSchema.parse(values.host) : void 0 });
+      const host = values.host ? hostSchema.parse(values.host) : void 0;
+      if (!values.json) progress2 = createProgress(io === defaultIo ? {} : {
+        write: (text2) => io.err(text2.replace(/\n$/, "")),
+        interactive: false
+      });
+      const result = await setupProject2(dir, { host, progress: progress2 });
+      progress2?.stop();
       io.out(values.json ? JSON.stringify(result, null, 2) : summarizeSetup2(result));
       return 0;
     }
@@ -6133,6 +6204,7 @@ async function runAutomationCli(argv, stdin = "", io = {
     io.out(values.json ? JSON.stringify(report, null, 2) : summarize(report));
     return report.status === "verified" ? 0 : report.status === "issues-remain" ? 1 : 2;
   } catch (error) {
+    progress2?.stop(false);
     const message2 = action === "setup" ? "Mason setup incomplete: " + automationFailure(error).message + ". Rerun the same setup command to resume; retained audit evidence is preserved." : action === "teardown" ? "Mason teardown incomplete: " + automationFailure(error).message + ". Inspect the reported input, then rerun teardown; knowledge and repair evidence are retained." : failureMessage(error);
     if (action === "hook" || isHookCommand(argv)) {
       io.out(JSON.stringify({ systemMessage: message2 }));
@@ -6149,7 +6221,7 @@ var inputArgs = process.argv.slice(2);
 var managedLaunch = inputArgs[0] === "--setup-host";
 var setupHost = managedLaunch ? inputArgs.splice(0, 2)[1] : void 0;
 var [command, ...args] = inputArgs;
-var usage = `Mason ${"0.17.1"}
+var usage = `Mason ${"0.17.2"}
 
 Usage: mason <command> [options]
 
@@ -6166,6 +6238,7 @@ Usage: mason <command> [options]
 
 Use mason <command> --help for options. npm users can keep using mason-auto,
 mason-audit, mason-review, mason-drift, mason-hook and mason-mcp.`;
+var progress;
 try {
   if (managedLaunch) {
     if (!setupHost || !["codex", "claude"].includes(setupHost) || !["mcp", "auto"].includes(command)) throw new Error("Invalid setup invocation.");
@@ -6174,23 +6247,29 @@ try {
       await prepareLaunch2(setupHost, { allowInactive: command === "mcp" });
     }
   }
-  if (command === "internal-integration-version") console.log(JSON.stringify({ protocol: 1, version: "0.17.1" }));
+  if (command === "internal-integration-version") console.log(JSON.stringify({ protocol: 1, version: "0.17.2" }));
   else if (!command || ["--help", "-h", "help"].includes(command)) console.log(usage);
-  else if (["--version", "-v"].includes(command)) console.log("0.17.1");
+  else if (["--version", "-v"].includes(command)) console.log("0.17.2");
   else if (command === "internal-install") {
     if (args.length) throw new Error("internal-install takes no arguments.");
     const { installStandalone: installStandalone2 } = await Promise.resolve().then(() => (init_install2(), install_exports2));
     const bundleRoot = fileURLToPath2(new URL("../..", import.meta.url));
-    const installed = await installStandalone2(bundleRoot);
-    console.log(`Installed Mason ${installed.version} in ${installed.home}.
+    progress = createProgress();
+    const installed = await installStandalone2(bundleRoot, progress);
+    progress.stop();
+    const outcome = installed.previousVersion && installed.previousVersion !== installed.version ? `Updated Mason ${installed.previousVersion} \u2192 ${installed.version}` : `Installed Mason ${installed.version}`;
+    console.log(`${outcome} in ${installed.home}.
 ${installed.path.message}`);
   } else if (command === "upgrade" || command === "uninstall") {
     if (args.includes("--help")) console.log(command === "upgrade" ? "Usage: mason upgrade [version]. Configured projects use the upgraded command on their next launch. Restart running assistants." : "Usage: mason uninstall. Removes the standalone user installation; project configuration and knowledge are retained. Run mason teardown in each project first to disconnect its integrations.");
     else {
       const { upgradeStandalone: upgradeStandalone2, uninstallStandalone: uninstallStandalone2 } = await Promise.resolve().then(() => (init_install2(), install_exports2));
       if (args.length > (command === "upgrade" ? 1 : 0)) throw new Error("Unexpected arguments.");
-      if (command === "upgrade") process.exitCode = await upgradeStandalone2(args[0]);
-      else console.log((process.platform === "win32" ? "Finishing installation cleanup after runtime exit: " : "Removed standalone installation: ") + await uninstallStandalone2() + ". Project configuration and knowledge were retained. Reinstall Mason to use its integrations.");
+      if (command === "upgrade") {
+        progress = createProgress();
+        process.exitCode = await upgradeStandalone2(args[0], progress);
+        if (process.exitCode === 0) console.log("Restart running assistants to use this installation. Existing project integrations use mason from PATH.");
+      } else console.log((process.platform === "win32" ? "Finishing installation cleanup after runtime exit: " : "Removed standalone installation: ") + await uninstallStandalone2() + ". Project configuration and knowledge were retained. Reinstall Mason to use its integrations.");
     }
   } else if (["setup", "teardown", "status", "check", "auto"].includes(command)) {
     const forwarded = command === "auto" ? args : [command, ...args];
@@ -6211,6 +6290,7 @@ ${installed.path.message}`);
     await import(binary.href);
   } else throw new Error("Unknown command: " + command + ". Run mason --help.");
 } catch (error) {
+  progress?.stop(false);
   const message2 = "Mason: " + (error instanceof Error ? error.message : String(error));
   if (command === "auto" && isHookCommand(args)) {
     console.log(JSON.stringify({ systemMessage: message2 + " Verification was not established." }));