dsh-windows-mcp 0.1.0 → 0.2.0

package/lib/index.js

@@ -33,12 +33,12 @@ import {
   BRIDGE_ROUTE,
   PREPARE_CANCEL_ROUTE,
   PREPARE_ROUTE,
-  createPrepare,
   dependencySnapshot,
   windowsMcpExecutable,
   windowsMcpVersionPin,
   writeBridgeOverride,
 } from "./dependency.js";
+import { UPDATE_ACTIONS, UPDATE_ROUTE, createUpdater } from "./updater.js";
 
 const PACKAGE_ID = "dsh-windows-mcp";
 const BRIDGE_ROW_ID = "windows-mcp-bridge";
@@ -67,8 +67,8 @@ const MAX_STATE_BODY_BYTES = 1024;
  *  Desktop control is opt-in: a fresh install starts OFF. */
 const computerUse = { enabled: false };
 
-/** The `uv tool install` driver, created in apply() once the logger exists. */
-let dependencyManager = null;
+/** The Windows-MCP version manager, created in apply() once the logger exists. */
+let updater = null;
 
 /* ------------------------------------------------------------------ *
  * small, throw-proof helpers
@@ -311,6 +311,25 @@ function buildReport(tools) {
     }`,
   );
 
+  const update = updater === null ? null : updater.view();
+  if (update !== null) {
+    const managed = update.versions;
+    lines.push(
+      `managed install : ${
+        managed.active === null
+          ? "none yet — the global `uv tool` installation is used (installing or updating creates one)"
+          : `v${managed.active} under ${managed.toolchainRoot}`
+      }`,
+    );
+    if (managed.previous !== null) lines.push(`  rollback to  : v${managed.previous}`);
+    if (managed.available.length > 0) lines.push(`  installed    : ${managed.available.map((version) => `v${version}`).join(", ")}`);
+    if (update.check.latest === null) {
+      lines.push("  latest       : not checked yet — press Check for updates in Settings → Plugins");
+    } else {
+      lines.push(`  latest       : v${update.check.latest}${managed.updateAvailable ? " — an update is available" : " — up to date"}`);
+    }
+  }
+
   if (uv === null && uvx === null) {
     advice.push(
       "Install uv (https://docs.astral.sh/uv/) and make sure `uvx` is on the PATH of the process that runs DSH — without it the bridge cannot start Windows-MCP.",
@@ -490,13 +509,34 @@ function registerStateRoute(ctx, warn) {
           }
         };
 
-        const snapshot = () => ({
-          enabled: computerUse.enabled,
-          bridged: bridgedToolCount(scoped.get?.("tools")),
-          serverName: "windows",
-          dependency: dependencySnapshot(which, windowsMcpVersionPin(readText(patchPath))),
-          prepare: dependencyManager === null ? null : dependencyManager.snapshot(),
-        });
+        /** Map the version manager's install progress onto the prepare shape the page polls. */
+        const prepareSnapshot = () => {
+          if (updater === null) return null;
+          const install = updater.view().install;
+          return {
+            phase: install.phase === "installing" ? "running" : install.phase,
+            startedAt: install.startedAt,
+            finishedAt: install.finishedAt,
+            error: install.error,
+            log: install.log,
+            bridge: install.bridge,
+            version: install.version,
+            mirror: install.mirror,
+          };
+        };
+
+        const snapshot = () => {
+          const legacy = dependencySnapshot(which, windowsMcpVersionPin(readText(patchPath)));
+          const update = updater === null ? null : updater.view();
+          return {
+            enabled: computerUse.enabled,
+            bridged: bridgedToolCount(scoped.get?.("tools")),
+            serverName: "windows",
+            dependency: updater === null ? legacy : updater.dependencyView(legacy),
+            prepare: prepareSnapshot(),
+            update,
+          };
+        };
 
         const handler = (request, response) => {
           if (request.method === "GET") {
@@ -536,7 +576,7 @@ function registerStateRoute(ctx, warn) {
           request.on("error", () => respond(response, 400, { error: "request failed" }));
         };
 
-        /** Start the dependency install the Plugins page shows a button for. */
+        /** Start installing the pinned (or newest known) Windows-MCP into its own tool root. */
         const prepareHandler = (request, response) => {
           if (request.method === "GET") {
             respond(response, 200, snapshot());
@@ -546,17 +586,22 @@ function registerStateRoute(ctx, warn) {
             respond(response, 405, { error: "method not allowed" });
             return;
           }
-          if (dependencyManager === null) {
-            respond(response, 503, { error: "the dependency manager is not ready" });
+          if (updater === null) {
+            respond(response, 503, { error: "the version manager is not ready" });
             return;
           }
-          const started = dependencyManager.start();
-          respond(response, started.started ? 202 : 409, {
-            started: started.started,
-            reason: started.reason ?? null,
-            spec: started.spec ?? null,
-            prepare: dependencyManager.snapshot(),
-          });
+          const view = updater.view();
+          const target = view.versions.pinned ?? view.check.latest;
+          if (target === null) {
+            respond(response, 409, { started: false, reason: "no Windows-MCP version is known yet", prepare: prepareSnapshot() });
+            return;
+          }
+          if (view.install.phase === "installing") {
+            respond(response, 409, { started: false, reason: "an install is already running", prepare: prepareSnapshot() });
+            return;
+          }
+          void updater.installVersion(target);
+          respond(response, 202, { started: true, spec: `windows-mcp@${target}`, prepare: prepareSnapshot() });
         };
 
         /** Stop a running install. */
@@ -565,31 +610,105 @@ function registerStateRoute(ctx, warn) {
             respond(response, 405, { error: "method not allowed" });
             return;
           }
-          const cancelled = dependencyManager !== null && dependencyManager.cancel();
-          respond(response, 200, { cancelled, prepare: dependencyManager === null ? null : dependencyManager.snapshot() });
+          const result = updater === null ? { cancelled: false } : updater.cancel();
+          respond(response, 200, { cancelled: result.cancelled === true, prepare: prepareSnapshot() });
         };
 
-        /** Point the bridge at the installed executable (also done after install). */
+        /** Point the bridge at the active executable (managed install first). */
         const bridgeHandler = (request, response) => {
           if (request.method !== "POST") {
             respond(response, 405, { error: "method not allowed" });
             return;
           }
-          const executable = windowsMcpExecutable();
+          const view = updater === null ? null : updater.view();
+          const executable = view?.versions?.activeExecutable ?? windowsMcpExecutable();
           if (executable === null) {
             respond(response, 409, {
               ok: false,
-              error: "Windows-MCP is not installed through `uv tool` yet, so there is nothing to point the bridge at.",
+              error: "Windows-MCP is not installed yet, so there is nothing to point the bridge at.",
             });
             return;
           }
           respond(response, 200, writeBridgeOverride(executable, { warn, version: selfVersion() }));
         };
 
+        /** Check for, install, activate and roll back Windows-MCP versions. */
+        const updateHandler = (request, response) => {
+          if (request.method === "GET") {
+            respond(response, 200, updater === null ? { error: "the version manager is not ready" } : updater.view());
+            return;
+          }
+          if (request.method !== "POST") {
+            respond(response, 405, { error: "method not allowed" });
+            return;
+          }
+          if (updater === null) {
+            respond(response, 503, { error: "the version manager is not ready" });
+            return;
+          }
+          const chunks = [];
+          let size = 0;
+          request.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_STATE_BODY_BYTES) {
+              request.destroy();
+              return;
+            }
+            chunks.push(chunk);
+          });
+          request.on("end", () => {
+            let body;
+            try {
+              body = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+            } catch {
+              respond(response, 400, { error: "invalid JSON body" });
+              return;
+            }
+            const action = typeof body?.action === "string" ? body.action : "";
+            const version = typeof body?.version === "string" && body.version !== "" ? body.version : null;
+            const allowed = [...UPDATE_ACTIONS, "cancel"];
+            if (!allowed.includes(action)) {
+              respond(response, 400, { error: `expected { action } in ${allowed.join(", ")}` });
+              return;
+            }
+            if (action === "check") {
+              void updater.check({ force: true });
+              respond(response, 202, { started: true, action });
+              return;
+            }
+            if (action === "install") {
+              const view = updater.view();
+              const target = version ?? view.check.latest ?? view.versions.pinned;
+              if (target === null) {
+                respond(response, 409, { ok: false, error: "no Windows-MCP version is known yet — check for updates first" });
+                return;
+              }
+              void updater.installVersion(target);
+              respond(response, 202, { started: true, action, version: target });
+              return;
+            }
+            if (action === "cancel") {
+              respond(response, 200, updater.cancel());
+              return;
+            }
+            if (action === "activate") {
+              if (version === null) {
+                respond(response, 400, { error: "activate needs { version }" });
+                return;
+              }
+              respond(response, 200, updater.activateInstalled(version));
+              return;
+            }
+            respond(response, 200, updater.rollback());
+          });
+          request.on("error", () => respond(response, 400, { error: "request failed" }));
+        };
+
         scoped.webServer.register({ kind: "exact", path: STATE_ROUTE, handler });
         scoped.webServer.register({ kind: "exact", path: PREPARE_ROUTE, handler: prepareHandler });
         scoped.webServer.register({ kind: "exact", path: PREPARE_CANCEL_ROUTE, handler: cancelHandler });
         scoped.webServer.register({ kind: "exact", path: BRIDGE_ROUTE, handler: bridgeHandler });
+        scoped.webServer.register({ kind: "exact", path: UPDATE_ROUTE, handler: updateHandler });
       } catch (error) {
         warn(`could not register the Computer Use state route: ${String(error)}`);
       }
@@ -607,16 +726,24 @@ export function apply(ctx) {
   try {
     const warn = makeLogger(ctx);
     computerUse.enabled = readComputerUse().enabled;
-    dependencyManager = createPrepare({
+    updater = createUpdater({
       warn,
       resolver: which,
       pinned: windowsMcpVersionPin(readText(patchPath)),
-      afterInstall: (executable) => writeBridgeOverride(executable, { warn, version: selfVersion() }),
+      writeBridge: (executable) => writeBridgeOverride(executable, { warn, version: selfVersion() }),
     });
     auditStartup(warn);
     registerDoctor(ctx, warn);
     registerStateRoute(ctx, warn);
     registerToolGate(ctx, warn);
+    // Check for a newer Windows-MCP build in the background (cheap: a ranged
+    // read per mirror, cached for hours). The page shows the result; the boot
+    // never waits for it, and a failure only costs the last known answer.
+    try {
+      void updater.check({ force: false }).catch(() => {});
+    } catch {
+      /* a failed check is not a boot problem */
+    }
   } catch {
     /* apply() must not throw, whatever happens */
   }

package/lib/installs.js

@@ -0,0 +1,196 @@
+/**
+ * dsh-windows-mcp — managed installs (host side).
+ *
+ * Every Windows-MCP version this plugin installs lives in its own `uv` tool
+ * root:
+ *
+ *   <home>/dsh-windows-mcp/toolchain/<version>/        ← UV_TOOL_DIR
+ *   <home>/dsh-windows-mcp/toolchain/<version>/windows-mcp/Scripts/windows-mcp.exe
+ *   <home>/dsh-windows-mcp/toolchain/<version>/manifest.json
+ *
+ * Isolating by version is what makes "update" safe: the previous environment is
+ * never overwritten, so rolling back is a pointer move plus a bridge rewrite —
+ * no download, no reinstall. `<home>/dsh-windows-mcp.versions.json` remembers
+ * which version is active, which one it replaced, and what the last update
+ * check saw.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dshHome, toolVersionIn } from "./dependency.js";
+
+const VERSION_PATTERN = /^\d[0-9A-Za-z.+_-]*$/u;
+const STATE_VERSION = 1;
+
+/** Root that holds one tool root per Windows-MCP version. */
+export function managedToolchainRoot(home = dshHome()) {
+  return join(home, "dsh-windows-mcp", "toolchain");
+}
+
+/** `…/<version>` — the directory handed to `UV_TOOL_DIR`. */
+export function versionToolRoot(root, version) {
+  if (typeof root !== "string" || root === "") throw new TypeError("root must be a non-empty string");
+  if (typeof version !== "string" || !VERSION_PATTERN.test(version)) throw new TypeError(`invalid Windows-MCP version: ${String(version)}`);
+  return join(root, version);
+}
+
+/** `…/<version>/windows-mcp` — the tool environment inside the version root. */
+export function toolDirectoryFor(root, version) {
+  return join(versionToolRoot(root, version), "windows-mcp");
+}
+
+/** Executable path for a tool directory, or null when the tool is not there. */
+export function executableIn(toolDirectory) {
+  if (typeof toolDirectory !== "string" || toolDirectory === "") return null;
+  for (const candidate of [join(toolDirectory, "Scripts", "windows-mcp.exe"), join(toolDirectory, "bin", "windows-mcp")]) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/** Executable of a managed version, or null when it is not installed. */
+export function managedExecutable(root, version) {
+  return executableIn(toolDirectoryFor(root, version));
+}
+
+/** `…/<version>/manifest.json` */
+export function manifestPath(root, version) {
+  return join(versionToolRoot(root, version), "manifest.json");
+}
+
+/** Read the install manifest of one managed version (null when absent). */
+export function readManifest(root, version) {
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath(root, version), "utf8"));
+    return parsed !== null && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Write the install manifest of one managed version. */
+export function writeManifest(root, version, payload = {}) {
+  const target = manifestPath(root, version);
+  mkdirSync(versionToolRoot(root, version), { recursive: true });
+  const manifest = {
+    version,
+    installedAt: new Date().toISOString(),
+    executable: managedExecutable(root, version),
+    ...payload,
+  };
+  writeFileSync(target, `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
+}
+
+/** Every managed version, newest first. */
+export function listManagedVersions(root = managedToolchainRoot()) {
+  let names = [];
+  try {
+    names = readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && VERSION_PATTERN.test(entry.name))
+      .map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+  const versions = names.map((version) => {
+    const toolDirectory = toolDirectoryFor(root, version);
+    const manifest = readManifest(root, version);
+    const executable = executableIn(toolDirectory);
+    return {
+      version,
+      toolDirectory,
+      executable,
+      installedVersion: toolVersionIn(toolDirectory),
+      manifest,
+      installedAt: typeof manifest?.installedAt === "string" ? manifest.installedAt : null,
+      mirror: typeof manifest?.mirror === "string" ? manifest.mirror : null,
+      ready: executable !== null,
+    };
+  });
+  return versions
+    .filter((entry) => entry.ready)
+    .sort((left, right) => compareVersionsDescending(left.version, right.version));
+}
+
+/** Local sort helper — newest first, numeric segments. */
+function compareVersionsDescending(left, right) {
+  const leftParts = left.split(/[.+-]/u).map((part) => (/^\d+$/u.test(part) ? Number(part) : part));
+  const rightParts = right.split(/[.+-]/u).map((part) => (/^\d+$/u.test(part) ? Number(part) : part));
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const leftPart = leftParts[index] ?? 0;
+    const rightPart = rightParts[index] ?? 0;
+    if (leftPart === rightPart) continue;
+    if (typeof leftPart === "number" && typeof rightPart === "number") return rightPart - leftPart;
+    return String(rightPart).localeCompare(String(leftPart));
+  }
+  return 0;
+}
+
+/** `<home>/dsh-windows-mcp.versions.json` */
+export function versionsStatePath(home = dshHome()) {
+  return join(home, "dsh-windows-mcp.versions.json");
+}
+
+/** A fresh, empty versions state. */
+export function emptyVersionsState() {
+  return { version: STATE_VERSION, active: null, previous: null, history: [], lastCheck: null };
+}
+
+/** Normalise anything read from disk into a usable state object. */
+function normalizeVersionsState(parsed) {
+  const state = emptyVersionsState();
+  if (parsed === null || typeof parsed !== "object") return state;
+  const version = (value) => (typeof value === "string" && VERSION_PATTERN.test(value) ? value : null);
+  state.active = version(parsed.active);
+  state.previous = version(parsed.previous);
+  if (Array.isArray(parsed.history)) {
+    state.history = parsed.history
+      .filter((entry) => entry !== null && typeof entry === "object" && version(entry.version) !== null)
+      .slice(-20)
+      .map((entry) => ({ version: version(entry.version), activatedAt: typeof entry.activatedAt === "string" ? entry.activatedAt : null }));
+  }
+  if (parsed.lastCheck !== null && typeof parsed.lastCheck === "object" && typeof parsed.lastCheck.at === "string") {
+    state.lastCheck = {
+      at: parsed.lastCheck.at,
+      latest: version(parsed.lastCheck.latest),
+      best: typeof parsed.lastCheck.best === "string" ? parsed.lastCheck.best : null,
+      mirrors: Array.isArray(parsed.lastCheck.mirrors) ? parsed.lastCheck.mirrors : [],
+    };
+  }
+  return state;
+}
+
+/** Read the versions state, tolerating a missing or damaged file. */
+export function readVersionsState(home = dshHome()) {
+  try {
+    return normalizeVersionsState(JSON.parse(readFileSync(versionsStatePath(home), "utf8")));
+  } catch {
+    return emptyVersionsState();
+  }
+}
+
+/** Write the versions state atomically (write-then-rename). */
+export function writeVersionsState(state, home = dshHome()) {
+  const target = versionsStatePath(home);
+  const temporary = `${target}.tmp`;
+  const payload = { ...emptyVersionsState(), ...state, version: STATE_VERSION, history: state.history?.slice(-20) ?? [] };
+  writeFileSync(temporary, `${JSON.stringify(payload, null, 2)}\n`);
+  renameSync(temporary, target);
+  return payload;
+}
+
+/** Record `version` as active and the previous active as its rollback target. */
+export function activateVersion(state, version) {
+  if (typeof version !== "string" || !VERSION_PATTERN.test(version)) throw new TypeError(`invalid Windows-MCP version: ${String(version)}`);
+  const previous = state.active !== null && state.active !== version ? state.active : null;
+  const history = [...(state.history ?? []), { version, activatedAt: new Date().toISOString() }].slice(-20);
+  return { ...state, active: version, previous, history };
+}
+
+/** Where the bridge should point: the active managed version's executable. */
+export function activeInstall(state, home = dshHome()) {
+  const version = state?.active ?? null;
+  if (version === null) return null;
+  const executable = managedExecutable(managedToolchainRoot(home), version);
+  if (executable === null) return null;
+  return { version, executable, toolDirectory: toolDirectoryFor(managedToolchainRoot(home), version) };
+}