agent-dealer 0.1.13 → 0.3.0

package/dist/update-check.js

@@ -1,32 +1,15 @@
+import { detectInstallKind, runManagedCliEntryHooks } from "./managed/index.js";
+import { installAgentDealerVersion } from "./upgrade.js";
+import { fetchLatestPublishedVersion } from "./npm-registry.js";
+import { getVersion } from "./version.js";
+import { compareSemver } from "./managed/semver.js";
 import fs from "node:fs";
 import path from "node:path";
 import readline from "node:readline";
 import { prodHomeDir } from "./env.js";
-import { getVersion } from "./version.js";
-import { fetchLatestPublishedVersion } from "./npm-registry.js";
-import { installAgentDealerVersion } from "./upgrade.js";
 const PKG_NAME = "agent-dealer";
 const CACHE_FILE = ".agent-dealer-update-check.json";
 const CHECK_THROTTLE_MS = 24 * 60 * 60 * 1000;
-function parseXyzVersion(v) {
-    const m = v.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
-    if (!m)
-        return undefined;
-    return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]) };
-}
-function isNewer(latest, current) {
-    const a = parseXyzVersion(latest);
-    const b = parseXyzVersion(current);
-    if (!a || !b)
-        return false;
-    if (a.major !== b.major)
-        return a.major > b.major;
-    if (a.minor !== b.minor)
-        return a.minor > b.minor;
-    if (a.patch !== b.patch)
-        return a.patch > b.patch;
-    return false;
-}
 async function promptYesNo(message) {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
         return false;
@@ -36,16 +19,14 @@ async function promptYesNo(message) {
     return answer.trim().toLowerCase().startsWith("y");
 }
 function cachePath() {
-    const home = prodHomeDir();
-    return path.join(home, CACHE_FILE);
+    return path.join(prodHomeDir(), CACHE_FILE);
 }
 function readCache() {
     try {
         const p = cachePath();
         if (!fs.existsSync(p))
             return undefined;
-        const raw = fs.readFileSync(p, "utf8");
-        return JSON.parse(raw);
+        return JSON.parse(fs.readFileSync(p, "utf8"));
     }
     catch {
         return undefined;
@@ -53,23 +34,34 @@ function readCache() {
 }
 function writeCache(next) {
     try {
-        const home = prodHomeDir();
-        fs.mkdirSync(home, { recursive: true });
+        fs.mkdirSync(prodHomeDir(), { recursive: true });
         fs.writeFileSync(cachePath(), JSON.stringify(next), "utf8");
     }
     catch {
-        // Ignore cache write failures (permissions, read-only FS, etc).
+        // ignore
     }
 }
+/** npm-global / unknown path — keep TTY prompt behavior. Managed uses hooks instead. */
 export async function maybeCheckForUpdateOnRun() {
+    if (detectInstallKind() === "managed") {
+        const { activated } = runManagedCliEntryHooks({ allowActivate: true });
+        if (activated) {
+            console.log(`[agent-dealer] Activated managed version ${activated}`);
+            console.log("Re-run your command to use the new version.");
+            return { upgraded: true };
+        }
+        return { upgraded: false };
+    }
     if (process.env.AGENT_DEALER_DISABLE_UPGRADE_CHECK === "1") {
         return { upgraded: false };
     }
+    if (process.env.AGENT_DEALER_DISABLE_AUTOUPDATER === "1") {
+        return { upgraded: false };
+    }
     const current = getVersion();
     const cache = readCache();
     if (cache?.checkedAt && Date.now() - cache.checkedAt < CHECK_THROTTLE_MS) {
-        // Throttle network checks, but still report based on cached latestVersion.
-        if (cache.latestVersion && isNewer(cache.latestVersion, current)) {
+        if (cache.latestVersion && compareSemver(cache.latestVersion, current) > 0) {
             console.log(`Update available: ${current} -> ${cache.latestVersion}`);
             const autoUpgrade = ["1", "true", "yes"].includes(process.env.AGENT_DEALER_AUTO_UPGRADE?.trim().toLowerCase() ?? "");
             if (autoUpgrade) {
@@ -79,9 +71,9 @@ export async function maybeCheckForUpdateOnRun() {
             const canPrompt = process.stdin.isTTY && process.stdout.isTTY;
             if (!canPrompt) {
                 console.log(`Run: agent-dealer upgrade`);
+                console.log("Tip: agent-dealer install  # managed auto-updates");
                 return { upgraded: false };
             }
-            // Prompt at most once per throttle window to avoid nagging.
             const promptAgeMs = cache.promptedAt ? Date.now() - cache.promptedAt : Infinity;
             if (promptAgeMs >= CHECK_THROTTLE_MS) {
                 writeCache({ ...cache, promptedAt: Date.now() });
@@ -89,20 +81,16 @@ export async function maybeCheckForUpdateOnRun() {
                 if (!ok)
                     return { upgraded: false };
             }
-            else {
-                // Recently prompted; do not prompt again.
-            }
             const code = await installAgentDealerVersion(cache.latestVersion);
             return { upgraded: code === 0 };
         }
         return { upgraded: false };
     }
     const latest = await fetchLatestPublishedVersion(PKG_NAME);
-    // Always write checkedAt so we don't hammer the registry on repeated failures.
     writeCache({ checkedAt: Date.now(), latestVersion: latest, promptedAt: cache?.promptedAt });
     if (!latest || latest === current)
         return { upgraded: false };
-    if (!isNewer(latest, current))
+    if (compareSemver(latest, current) <= 0)
         return { upgraded: false };
     const autoUpgrade = ["1", "true", "yes"].includes(process.env.AGENT_DEALER_AUTO_UPGRADE?.trim().toLowerCase() ?? "");
     console.log(`Update available: ${current} -> ${latest}`);

package/dist/upgrade.d.ts

@@ -2,5 +2,6 @@ export declare function printUpgradeHelp(): void;
 export declare function runUpgrade(options?: {
     toVersion?: string;
     yes?: boolean;
+    check?: boolean;
 }): Promise<number>;
 export declare function installAgentDealerVersion(version: string): Promise<number>;

package/dist/upgrade.js

@@ -1,12 +1,15 @@
 import { spawn } from "node:child_process";
 import readline from "node:readline";
+import { activateVersion, compareSemver, detectInstallKind, fetchLatestVersion, installCliVersionToPrefix, readCurrentManagedVersion, } from "./managed/index.js";
 import { fetchLatestPublishedVersion } from "./npm-registry.js";
+import { getVersion } from "./version.js";
 const PKG_NAME = "agent-dealer";
 export function printUpgradeHelp() {
     console.log(`Usage:
-  agent-dealer upgrade [--to VERSION] [--yes]
+  agent-dealer upgrade [--to VERSION] [--yes] [--check]
 
-Installs the latest global version of agent-dealer (or --to VERSION).`);
+Managed install: download into ~/.agent-dealer/versions and activate.
+npm-global: npm install -g agent-dealer@VERSION.`);
 }
 function parseBooleanLike(s) {
     const v = s?.trim().toLowerCase();
@@ -32,14 +35,53 @@ async function runNpmGlobalInstall(version) {
 }
 export async function runUpgrade(options = {}) {
     const toVersion = options.toVersion?.trim();
+    if (detectInstallKind() === "managed") {
+        const current = readCurrentManagedVersion() ?? getVersion();
+        const latest = toVersion ?? (await fetchLatestVersion());
+        if (!latest) {
+            console.error(`Could not resolve latest version for ${PKG_NAME}.`);
+            return 1;
+        }
+        console.log(`Current: ${current}`);
+        console.log(`Latest:  ${latest}`);
+        console.log("Install: managed");
+        if (!toVersion && compareSemver(latest, current) <= 0) {
+            console.log("Already on the latest version.");
+            return 0;
+        }
+        if (options.check) {
+            console.log("Update available. Run: agent-dealer upgrade");
+            return 0;
+        }
+        console.log(`Upgrading managed install ${PKG_NAME} → ${latest} ...`);
+        const result = await installCliVersionToPrefix(latest);
+        if (!result.ok) {
+            console.error(`Upgrade failed: ${result.error}`);
+            return 1;
+        }
+        activateVersion(latest);
+        console.log("Upgrade complete. Restart any running agent-dealer process.");
+        return 0;
+    }
     let version = toVersion ?? (await fetchLatestPublishedVersion(PKG_NAME));
     if (!version) {
         console.error(`Could not resolve latest version for ${PKG_NAME}.`);
         return 1;
     }
-    const autoYes = options.yes ??
-        parseBooleanLike(process.env.AGENT_DEALER_UPGRADE_YES) ??
-        false;
+    console.log(`Current: ${getVersion()}`);
+    console.log(`Latest:  ${version}`);
+    console.log("Install: npm-global (or unknown)");
+    if (options.check) {
+        if (compareSemver(version, getVersion()) > 0) {
+            console.log("Update available. Run: agent-dealer upgrade");
+            console.log("Tip: agent-dealer install  # managed auto-updates (data unchanged)");
+        }
+        else {
+            console.log("Already on the latest version.");
+        }
+        return 0;
+    }
+    const autoYes = options.yes ?? parseBooleanLike(process.env.AGENT_DEALER_UPGRADE_YES) ?? false;
     if (!autoYes) {
         const ok = await confirmPrompt(`Upgrade ${PKG_NAME} to ${version} via "npm install -g ${PKG_NAME}@${version}"? [y/N] `);
         if (!ok) {
@@ -50,10 +92,17 @@ export async function runUpgrade(options = {}) {
     const code = await runNpmGlobalInstall(version);
     if (code === 0) {
         console.log(`Upgraded to ${PKG_NAME}@${version}. Re-run your command to use the new version.`);
+        console.log("Tip: agent-dealer install  # switch CLI to managed auto-updates (data unchanged)");
     }
     return code;
 }
-// Used by update-check: prompts happen elsewhere, so we only do the install.
 export async function installAgentDealerVersion(version) {
+    if (detectInstallKind() === "managed") {
+        const result = await installCliVersionToPrefix(version);
+        if (!result.ok)
+            return 1;
+        activateVersion(version);
+        return 0;
+    }
     return runNpmGlobalInstall(version);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dealer",
-  "version": "0.1.13",
+  "version": "0.3.0",
   "description": "Human control plane for agent execution — queue, plan approval, audit",
   "license": "MIT",
   "type": "module",