multiclaw 0.5.0 → 0.5.1

package/dist/commands/upgrade.d.ts

@@ -1 +1,30 @@
+/** Which package manager owns the copy of multiclaw that is currently running. */
+export type Installer = "npm" | "pnpm" | "bun" | "yarn" | "unknown";
+/** Walk up from `start` to the package.json that declares this package. */
+export declare function findPackageRoot(start: string): string | undefined;
+/** Read the installed version straight from disk (no module cache to go stale). */
+export declare function readInstalledVersion(pkgRoot: string): string | undefined;
+/**
+ * Identify the installer from the on-disk location of the running package.
+ *
+ * This is the whole point of the command: `npm install -g` writes to npm's
+ * prefix, which is not necessarily where the binary on PATH came from. A user
+ * with a pnpm global install used to get a silent no-op upgrade — npm installed
+ * a fresh copy somewhere else while `multiclaw --version` kept reporting the
+ * pnpm one. Upgrading must therefore target the manager that owns this copy.
+ */
+export declare function detectInstaller(pkgRoot: string): Installer;
+type Exec = (command: string, mode: "capture" | "inherit") => string;
+export interface UpgradeContext {
+    pkgRoot: string;
+    currentVersion: string;
+    installer: Installer;
+    /** Re-read after installing: the on-disk copy is what `--version` reports. */
+    readVersion: (pkgRoot: string) => string | undefined;
+    exec: Exec;
+}
+/** Resolve the running install. `undefined` means it is not an installed copy. */
+export declare function createUpgradeContext(): UpgradeContext | undefined;
+export declare function runUpgrade(ctx: UpgradeContext): Promise<void>;
 export declare function upgradeCommand(): Promise<void>;
+export {};

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
 // src/commands/doctor.ts
@@ -716,12 +716,12 @@ var FileLogWriter = class {
     this.streams.clear();
     return Promise.all(
       streams.map(
-        (s) => new Promise((resolve4) => {
+        (s) => new Promise((resolve5) => {
           if (s.destroyed || s.writableEnded) {
-            resolve4();
+            resolve5();
             return;
           }
-          s.end(() => resolve4());
+          s.end(() => resolve5());
         })
       )
     ).then(() => void 0);
@@ -919,40 +919,132 @@ async function tuiCommand(options) {
 
 // src/commands/upgrade.ts
 import { execSync } from "child_process";
-import { createRequire as createRequire2 } from "module";
-var require2 = createRequire2(import.meta.url);
-async function upgradeCommand() {
-  const { version: currentVersion } = require2("../package.json");
-  console.log(`Current version: v${currentVersion}`);
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "multiclaw";
+var RED2 = "\x1B[31m";
+var GREEN2 = "\x1B[32m";
+var RESET2 = "\x1B[0m";
+function readManifest(dir) {
+  const manifest = join4(dir, "package.json");
+  if (!existsSync5(manifest)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(manifest, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function findPackageRoot(start) {
+  let dir = resolve4(start);
+  for (; ; ) {
+    if (readManifest(dir)?.name === PACKAGE_NAME) return dir;
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readInstalledVersion(pkgRoot) {
+  return readManifest(pkgRoot)?.version;
+}
+function detectInstaller(pkgRoot) {
+  const path6 = pkgRoot.replaceAll("\\", "/");
+  if (path6.includes("/pnpm/global/") || path6.includes("/.pnpm/")) return "pnpm";
+  if (path6.includes("/install/global/") || path6.includes("/.bun/")) return "bun";
+  if (path6.includes("/yarn/global/")) return "yarn";
+  if (path6.includes("/node_modules/")) return "npm";
+  return "unknown";
+}
+var COMMANDS = {
+  npm: { latest: "npm show multiclaw version", install: "npm install -g multiclaw@latest" },
+  pnpm: { latest: "pnpm view multiclaw version", install: "pnpm add -g multiclaw@latest" },
+  bun: void 0,
+  yarn: void 0,
+  unknown: void 0
+};
+var MANUAL = {
+  npm: "npm install -g multiclaw@latest",
+  pnpm: "pnpm add -g multiclaw@latest",
+  bun: "bun add -g multiclaw@latest",
+  yarn: "yarn global add multiclaw@latest",
+  unknown: "npm install -g multiclaw@latest"
+};
+function createUpgradeContext() {
+  const pkgRoot = findPackageRoot(dirname3(fileURLToPath(import.meta.url)));
+  if (!pkgRoot) return void 0;
+  const currentVersion = readInstalledVersion(pkgRoot);
+  if (!currentVersion) return void 0;
+  return {
+    pkgRoot,
+    currentVersion,
+    installer: detectInstaller(pkgRoot),
+    readVersion: readInstalledVersion,
+    exec: (command, mode) => {
+      if (mode === "inherit") {
+        execSync(command, { stdio: "inherit" });
+        return "";
+      }
+      return execSync(command, { encoding: "utf8" });
+    }
+  };
+}
+async function runUpgrade(ctx) {
+  const { pkgRoot, currentVersion, installer, exec, readVersion } = ctx;
+  console.log(`Current version: v${currentVersion} (${installer} install)`);
+  const commands = COMMANDS[installer];
+  if (!commands) {
+    const reason = installer === "unknown" ? `this copy is not a global install (${pkgRoot})` : `the ${installer} install at ${pkgRoot} cannot be upgraded automatically`;
+    console.error(`${RED2}Error: ${reason}. Run it manually: ${MANUAL[installer]}${RESET2}`);
+    process.exit(1);
+    return;
+  }
   console.log("Checking for updates...");
   let latestVersion;
   try {
-    latestVersion = execSync("npm show multiclaw version", { encoding: "utf8" }).trim();
+    latestVersion = exec(commands.latest, "capture").trim();
   } catch {
-    console.error("\x1B[31mError: Failed to fetch latest version from npm registry\x1B[0m");
+    console.error(`${RED2}Error: Failed to fetch latest version from npm registry${RESET2}`);
     process.exit(1);
     return;
   }
   if (latestVersion === currentVersion) {
-    console.log(`\x1B[32m\u2713\x1B[0m Already on the latest version (v${currentVersion})`);
+    console.log(`${GREEN2}\u2713${RESET2} Already on the latest version (v${currentVersion})`);
     return;
   }
   console.log(`Upgrading multiclaw v${currentVersion} \u2192 v${latestVersion}...`);
   try {
-    execSync("npm install -g multiclaw@latest", { stdio: "inherit" });
-    console.log(`\x1B[32m\u2713\x1B[0m Successfully upgraded to v${latestVersion}`);
+    exec(commands.install, "inherit");
   } catch {
+    console.error(`${RED2}Error: Upgrade failed. Try running manually: ${commands.install}${RESET2}`);
+    process.exit(1);
+    return;
+  }
+  const installedVersion = readVersion(pkgRoot);
+  if (installedVersion !== latestVersion) {
     console.error(
-      "\x1B[31mError: Upgrade failed. Try running manually: npm install -g multiclaw@latest\x1B[0m"
+      `${RED2}Error: ${commands.install} finished, but ${pkgRoot} still reports v${installedVersion ?? "unknown"}. Check for a second multiclaw install, then retry.${RESET2}`
     );
     process.exit(1);
+    return;
+  }
+  console.log(`${GREEN2}\u2713${RESET2} Successfully upgraded to v${latestVersion} (${pkgRoot})`);
+}
+async function upgradeCommand() {
+  const ctx = createUpgradeContext();
+  if (!ctx) {
+    console.error(
+      `${RED2}Error: could not locate the multiclaw package this process is running from.${RESET2}`
+    );
+    process.exit(1);
+    return;
   }
+  await runUpgrade(ctx);
 }
 
 // src/index.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname3(__filename2);
-var pkg = JSON.parse(readFileSync2(join4(__dirname2, "../package.json"), "utf-8"));
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname4(__filename2);
+var pkg = JSON.parse(readFileSync3(join5(__dirname2, "../package.json"), "utf-8"));
 var program = new Command();
 program.name("multiclaw").description("Multi-agent orchestration CLI").version(pkg.version, "-v, --version", "Display version number").action((options) => tuiCommand(options));
 program.command("init").description("Scaffold a config file (interactive)").action(() => initCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaw",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "bin": {
     "multiclaw": "dist/index.js"
@@ -30,8 +30,8 @@
     "@agentclientprotocol/claude-agent-acp": "^0.93.0",
     "@agentclientprotocol/codex-acp": "^2.2.2",
     "@inquirer/prompts": "^8.7.3",
-    "@multiclawcli/core": "0.5.0",
-    "@multiclawcli/dashboard": "0.5.0",
+    "@multiclawcli/core": "0.5.1",
+    "@multiclawcli/dashboard": "0.5.1",
     "commander": "^15.0.0",
     "jiti": "^2.7.0"
   },