cwm-assistant 0.2.0 → 0.3.0

package/dist/{cli-G7JDNOMO.js → cli-5CFP7QJS.js}

@@ -5,10 +5,10 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { spawn as spawn7 } from "node:child_process";
-import fs23 from "node:fs";
+import { spawn as spawn8 } from "node:child_process";
+import fs24 from "node:fs";
 import os9 from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
@@ -2619,7 +2619,7 @@ var Type = type_exports2;
 
 // ../../packages/contracts/src/assistant.ts
 var ASSISTANT_PROTOCOL = 1;
-var ASSISTANT_VERSION = "0.2.0";
+var ASSISTANT_VERSION = "0.3.0";
 var ASSISTANT_PORT = 46322;
 
 // ../../packages/contracts/src/index.ts
@@ -2676,11 +2676,14 @@ var GitCommandError = class extends Error {
     this.exitCode = exitCode;
   }
 };
+function longPathArgs(platform = process.platform) {
+  return platform === "win32" ? ["-c", "core.longpaths=true"] : [];
+}
 function runGit(cwd, args, options = {}) {
   return new Promise((resolve, reject) => {
     const execution = gitExecution.getStore();
     execution?.signal?.throwIfAborted();
-    const child = spawn(execution?.executable || "git", ["-C", cwd, ...args], {
+    const child = spawn(execution?.executable || "git", [...longPathArgs(), "-C", cwd, ...args], {
       signal: execution?.signal,
       shell: false,
       windowsHide: true,
@@ -4645,10 +4648,15 @@ var LocalJobs = class {
             if (!fs14.existsSync(source)) {
               const temporary = source + ".clone-" + randomUUID6();
               log("\u514B\u9686\u4ED3\u5E93\uFF1A" + repo.alias);
-              await runGit(namespace, ["clone", "--", repo.remoteUrl, temporary], {
-                onLog: log,
-                timeoutMs: 6e5
-              });
+              try {
+                await runGit(namespace, ["clone", "--", repo.remoteUrl, temporary], {
+                  onLog: log,
+                  timeoutMs: 6e5
+                });
+              } catch (error) {
+                fs14.rmSync(temporary, { recursive: true, force: true });
+                throw error;
+              }
               fs14.renameSync(temporary, source);
             }
             if (await runGit(source, ["config", "--get", "remote.origin.url"]) !== repo.remoteUrl)
@@ -5546,20 +5554,20 @@ function registerQueryRoutes(app, store) {
   app.get("/v1/repositories", async (request) => {
     const grant = requestGrant(request);
     const prefix = scopeKey(grant.workbenchId, grant.userId, "");
-    return Object.entries(store.state.repositories).filter(([key]) => key.startsWith(prefix)).map(([key, path27]) => ({ id: key.slice(prefix.length), path: path27 }));
+    return Object.entries(store.state.repositories).filter(([key]) => key.startsWith(prefix)).map(([key, path28]) => ({ id: key.slice(prefix.length), path: path28 }));
   });
   app.post("/v1/repositories/inspect", async (request) => {
     const body = request.body;
-    const path27 = body.path;
-    if (!path27 || !(await import("node:path")).default.isAbsolute(path27))
+    const path28 = body.path;
+    if (!path28 || !(await import("node:path")).default.isAbsolute(path28))
       throw new Error("\u8BF7\u9009\u62E9\u7EDD\u5BF9\u8DEF\u5F84");
     return git4(async () => ({
-      root: await runGit(path27, ["rev-parse", "--show-toplevel"]),
-      remoteUrl: (await runGit(path27, ["remote", "get-url", "origin"]).catch(() => "")).replace(
+      root: await runGit(path28, ["rev-parse", "--show-toplevel"]),
+      remoteUrl: (await runGit(path28, ["remote", "get-url", "origin"]).catch(() => "")).replace(
         /(https?:\/\/)[^/@\s]+@/gi,
         "$1"
       ),
-      branches: (await runGit(path27, [
+      branches: (await runGit(path28, [
         "for-each-ref",
         "--format=%(refname:short)",
         "refs/heads",
@@ -5977,8 +5985,121 @@ function registerReviewRoute(app, store, jobs) {
   });
 }
 
+// src/upgrade.ts
+import { spawn as spawn7 } from "node:child_process";
+import fs23 from "node:fs";
+import path26 from "node:path";
+function packageRoot(entry) {
+  let directory = path26.dirname(path26.resolve(entry));
+  for (let depth = 0; depth < 4; depth++) {
+    if (fs23.existsSync(path26.join(directory, "package.json"))) return directory;
+    directory = path26.dirname(directory);
+  }
+  return path26.dirname(path26.dirname(path26.resolve(entry)));
+}
+function isGlobalInstall(root, prefix) {
+  if (!prefix) return false;
+  const relative = path26.relative(path26.resolve(prefix), path26.resolve(root));
+  return Boolean(relative) && !relative.startsWith("..") && !path26.isAbsolute(relative);
+}
+function looksGlobal(root) {
+  const modules = path26.dirname(path26.resolve(root));
+  if (path26.basename(modules) !== "node_modules") return false;
+  return !fs23.existsSync(path26.join(path26.dirname(modules), "package.json"));
+}
+function isNewer(candidate, current) {
+  const parse = (value) => value.split("-")[0].split(".").map((part) => Number(part) || 0);
+  const [a, b] = [parse(candidate), parse(current)];
+  for (let index = 0; index < Math.max(a.length, b.length); index++) {
+    const [left, right] = [a[index] ?? 0, b[index] ?? 0];
+    if (left !== right) return left > right;
+  }
+  return !candidate.includes("-") && current.includes("-");
+}
+async function latestPublished() {
+  const response = await fetch("https://registry.npmjs.org/cwm-assistant/latest", {
+    signal: AbortSignal.timeout(5e3),
+    headers: { Accept: "application/vnd.npm.install-v1+json" }
+  });
+  if (!response.ok) throw new Error("\u65E0\u6CD5\u67E5\u8BE2 npm \u4E0A\u7684\u6700\u65B0\u7248\u672C");
+  const data = await response.json();
+  if (!data.version) throw new Error("npm \u8FD4\u56DE\u7684\u7248\u672C\u4FE1\u606F\u65E0\u6548");
+  return data.version;
+}
+var statusFile = (store) => path26.join(store.directory, "upgrade.json");
+function readStatus(store) {
+  try {
+    return JSON.parse(fs23.readFileSync(statusFile(store), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function registerUpgradeRoutes(app, store, entry, options = {}) {
+  const latestVersion = options.latest || latestPublished;
+  const root = packageRoot(entry);
+  const prefix = () => store.state.installPrefix || process.env.npm_config_prefix;
+  const global = isGlobalInstall(root, prefix()) || looksGlobal(root);
+  app.get("/v1/upgrade", async () => {
+    let latest = "";
+    let error = "";
+    try {
+      latest = await latestVersion();
+    } catch (cause) {
+      error = cause.message;
+    }
+    const status = readStatus(store);
+    const busy = Object.values(store.state.jobs).some((job) => job.state === "running");
+    return {
+      version: ASSISTANT_VERSION,
+      latest,
+      available: Boolean(latest) && isNewer(latest, ASSISTANT_VERSION),
+      // A source run (or an install we cannot locate) is not replaced from the page.
+      upgradeable: global,
+      reason: global ? "" : "\u5F53\u524D\u4E0D\u662F\u5168\u5C40 npm \u5B89\u88C5\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u5347\u7EA7",
+      error,
+      busy,
+      // A previous attempt that never reached the new version left this behind.
+      previous: status && status.target !== ASSISTANT_VERSION ? status : void 0
+    };
+  });
+  app.post("/v1/upgrade", async (_request, reply) => {
+    if (!global) return reply.code(409).send({ error: "\u5F53\u524D\u4E0D\u662F\u5168\u5C40 npm \u5B89\u88C5\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u5347\u7EA7" });
+    if (Object.values(store.state.jobs).some((job) => job.state === "running"))
+      return reply.code(409).send({ error: "\u672C\u5730\u4EFB\u52A1\u8FD0\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210\u540E\u518D\u5347\u7EA7" });
+    let latest;
+    try {
+      latest = await latestVersion();
+    } catch (cause) {
+      return reply.code(502).send({ error: cause.message });
+    }
+    if (!isNewer(latest, ASSISTANT_VERSION)) return { latest, started: false };
+    fs23.writeFileSync(
+      statusFile(store),
+      JSON.stringify({ target: latest, state: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+      { mode: 384 }
+    );
+    const child = spawn7(
+      process.execPath,
+      [
+        path26.join(root, "scripts", "upgrade.mjs"),
+        "--version",
+        latest,
+        "--state-dir",
+        store.directory
+      ],
+      { detached: true, stdio: "ignore", windowsHide: true, cwd: root }
+    );
+    child.unref();
+    if (store.state.autostart)
+      await configureAutostart(false, store.directory, entry).catch(() => {
+      });
+    setTimeout(() => process.exit(0), 300);
+    return { latest, started: true };
+  });
+}
+
 // src/server.ts
-async function buildAssistant(store, options = {}) {
+async function buildAssistant(store, options = {}, entry, upgrade = {}) {
   const app = Fastify({ logger: false, bodyLimit: 1024 * 1024 });
   const jobs = new LocalJobs(store);
   app.setErrorHandler(
@@ -5993,7 +6114,7 @@ async function buildAssistant(store, options = {}) {
       return;
     }
     const origin = request.headers.origin || "";
-    const path27 = request.url.split("?")[0];
+    const path28 = request.url.split("?")[0];
     let workbench = store.state.workbenches[origin];
     if (!workbench && trustedOrigin(origin)) {
       try {
@@ -6016,7 +6137,7 @@ async function buildAssistant(store, options = {}) {
       reply.header("Access-Control-Allow-Headers", "Authorization, Content-Type, X-CWM-Binding");
       return reply.code(204).send();
     }
-    if (path27 === "/v1/health" || path27 === "/v1/pairings") return;
+    if (path28 === "/v1/health" || path28 === "/v1/pairings") return;
     try {
       const token = request.headers.authorization?.replace(/^Bearer /, "") || "";
       const grant = verifyGrant(token, workbench.publicKey);
@@ -6135,6 +6256,8 @@ async function buildAssistant(store, options = {}) {
       input: job.input,
       state: job.state,
       error: job.error,
+      // The list is used to pick the newest job per workspace, so ordering needs a timestamp.
+      updatedAt: "updatedAt" in job ? job.updatedAt : void 0,
       deviceId: store.state.identity.id
     }));
   });
@@ -6164,6 +6287,7 @@ async function buildAssistant(store, options = {}) {
     return { ok: true };
   });
   registerLocalRoutes(app, store, options);
+  if (entry) registerUpgradeRoutes(app, store, entry, upgrade);
   registerQueryRoutes(app, store);
   registerAdoptRoutes(app, store, jobs);
   registerDeleteRoute(app, store, jobs);
@@ -6187,7 +6311,7 @@ async function cli(args, entry) {
     return;
   }
   const dirIndex = args.indexOf("--state-dir");
-  const directory = dirIndex >= 0 ? path26.resolve(args[dirIndex + 1]) : defaultStateDirectory();
+  const directory = dirIndex >= 0 ? path27.resolve(args[dirIndex + 1]) : defaultStateDirectory();
   const command = args[0] || "status";
   const store = new StateStore(directory);
   const control = async (action) => {
@@ -6213,14 +6337,14 @@ async function cli(args, entry) {
     }
     if (store.state.autostart) await startAutostart();
     else {
-      const log = fs23.openSync(path26.join(directory, "assistant.log"), "a", 384);
-      const child = spawn7(process.execPath, [entry, "serve", "--state-dir", directory], {
+      const log = fs24.openSync(path27.join(directory, "assistant.log"), "a", 384);
+      const child = spawn8(process.execPath, [entry, "serve", "--state-dir", directory], {
         detached: true,
         windowsHide: true,
         stdio: ["ignore", log, log]
       });
       child.unref();
-      fs23.closeSync(log);
+      fs24.closeSync(log);
     }
     const deadline = Date.now() + 1e4;
     while (Date.now() < deadline) {
@@ -6235,21 +6359,21 @@ async function cli(args, entry) {
     throw new Error("\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u8FD0\u884C cwm-assistant logs \u68C0\u67E5\u7AEF\u53E3\u548C\u8FD0\u884C\u73AF\u5883");
   }
   if (command === "serve") {
-    const lock = path26.join(directory, "process.lock");
-    if (fs23.existsSync(lock)) {
-      const pid = Number(fs23.readFileSync(lock, "utf8"));
+    const lock = path27.join(directory, "process.lock");
+    if (fs24.existsSync(lock)) {
+      const pid = Number(fs24.readFileSync(lock, "utf8"));
       try {
         process.kill(pid, 0);
         throw new Error("Workspace \u52A9\u624B\u5DF2\u8FD0\u884C");
       } catch (error) {
         if (error.code !== "ESRCH") throw error;
-        fs23.unlinkSync(lock);
+        fs24.unlinkSync(lock);
       }
     }
-    fs23.writeFileSync(lock, String(process.pid), { flag: "wx", mode: 384 });
+    fs24.writeFileSync(lock, String(process.pid), { flag: "wx", mode: 384 });
     store.reload();
     store.recover();
-    const { app, jobs } = await buildAssistant(store);
+    const { app, jobs } = await buildAssistant(store, {}, entry);
     app.post("/control", async (request, reply) => {
       const action = request.body.action;
       if (action === "status")
@@ -6270,12 +6394,12 @@ async function cli(args, entry) {
       return reply.code(400).send({ error: "\u63A7\u5236\u64CD\u4F5C\u65E0\u6548" });
     });
     app.addHook("onClose", async () => {
-      fs23.rmSync(lock, { force: true });
+      fs24.rmSync(lock, { force: true });
     });
     try {
       await app.listen({ host: "127.0.0.1", port: ASSISTANT_PORT });
     } catch (error) {
-      fs23.rmSync(lock, { force: true });
+      fs24.rmSync(lock, { force: true });
       throw error;
     }
     for (const signal of ["SIGTERM", "SIGINT"])
@@ -6284,6 +6408,9 @@ async function cli(args, entry) {
   }
   if (command === "start") return start();
   if (command === "install") {
+    const prefixIndex = args.indexOf("--prefix");
+    const installPrefix = prefixIndex >= 0 ? args[prefixIndex + 1] : store.state.installPrefix;
+    if (installPrefix) store.state.installPrefix = installPrefix;
     const running = await control("status").catch(() => void 0);
     if (running?.busy) {
       console.error(
@@ -6297,18 +6424,21 @@ async function cli(args, entry) {
       await control("stop").catch(() => {
       });
       const deadline = Date.now() + 1e4;
-      while (fs23.existsSync(path26.join(directory, "process.lock")) && Date.now() < deadline) {
+      while (fs24.existsSync(path27.join(directory, "process.lock")) && Date.now() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, 100));
       }
     }
+    let autostart = false;
     try {
       await configureAutostart(true, directory, entry);
-      store.reload();
-      store.state.autostart = true;
-      store.save();
+      autostart = true;
     } catch {
       console.error("\u672A\u80FD\u6CE8\u518C\u767B\u5F55\u81EA\u542F\u52A8\uFF0C\u52A9\u624B\u5C06\u53EA\u4F5C\u4E3A\u540E\u53F0\u8FDB\u7A0B\u8FD0\u884C\u3002");
     }
+    store.reload();
+    store.state.autostart = autostart;
+    if (installPrefix) store.state.installPrefix = installPrefix;
+    store.save();
     await start();
     return;
   }
@@ -6326,9 +6456,9 @@ async function cli(args, entry) {
     return;
   }
   if (command === "logs") {
-    const file = path26.join(directory, "assistant.log");
+    const file = path27.join(directory, "assistant.log");
     console.log(
-      fs23.existsSync(file) ? fs23.readFileSync(file, "utf8").split("\n").slice(-100).join("\n") : "\u6682\u65E0\u65E5\u5FD7"
+      fs24.existsSync(file) ? fs24.readFileSync(file, "utf8").split("\n").slice(-100).join("\n") : "\u6682\u65E0\u65E5\u5FD7"
     );
     return;
   }
@@ -6343,10 +6473,10 @@ async function cli(args, entry) {
       await control("stop").catch(() => {
       });
       const deadline = Date.now() + 1e4;
-      while (fs23.existsSync(path26.join(directory, "process.lock")) && Date.now() < deadline) {
+      while (fs24.existsSync(path27.join(directory, "process.lock")) && Date.now() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, 100));
       }
-      if (fs23.existsSync(path26.join(directory, "process.lock")))
+      if (fs24.existsSync(path27.join(directory, "process.lock")))
         throw new Error("\u52A9\u624B\u5C1A\u672A\u505C\u6B62\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u672A\u4FEE\u6539\u672C\u5730\u72B6\u6001");
     }
     store.reload();
@@ -6381,11 +6511,11 @@ async function cli(args, entry) {
         {
           node: process.version,
           nodePath: process.execPath,
-          entryExists: fs23.existsSync(entry),
+          entryExists: fs24.existsSync(entry),
           git: store.state.git,
           gitVersion,
           platform: process.platform,
-          rootExists: Boolean(store.state.root && fs23.existsSync(store.state.root)),
+          rootExists: Boolean(store.state.root && fs24.existsSync(store.state.root)),
           configuredWorkbenches: Object.keys(store.state.workbenches),
           autostart: store.state.autostart,
           process: await control("status").catch(() => "\u672A\u8FD0\u884C")
@@ -6426,9 +6556,9 @@ async function cli(args, entry) {
         }
       }
       if (rootArg) {
-        if (!path26.isAbsolute(rootArg) || !fs23.statSync(rootArg).isDirectory())
+        if (!path27.isAbsolute(rootArg) || !fs24.statSync(rootArg).isDirectory())
           throw new Error("\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u662F\u5DF2\u5B58\u5728\u7684\u7EDD\u5BF9\u8DEF\u5F84");
-        store.state.root = fs23.realpathSync(rootArg);
+        store.state.root = fs24.realpathSync(rootArg);
       }
       const auto = wantAutostart || !assumeYes && await ask("\u767B\u5F55\u7535\u8111\u65F6\u81EA\u52A8\u542F\u52A8\uFF1F[Y/n] ") !== "n";
       store.save();
@@ -6458,4 +6588,4 @@ async function cli(args, entry) {
 export {
   cli
 };
-//# sourceMappingURL=cli-G7JDNOMO.js.map
+//# sourceMappingURL=cli-5CFP7QJS.js.map