adhdev 0.8.39 → 0.8.41

package/dist/cli/index.js

@@ -2856,7 +2856,7 @@ var init_chat_history = __esm({
           const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
           fs3.appendFileSync(filePath, lines, "utf-8");
           const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
-          if (messages.length < prevCount * 0.5 && prevCount > 3) {
+          if (!historySessionId && messages.length < prevCount * 0.5 && prevCount > 3) {
             seenHashes.clear();
             this.lastSeenSignatures.delete(dedupKey);
             this.lastSeenTurnSignatures.delete(dedupKey);
@@ -5389,16 +5389,7 @@ async function handleSendChat(h, args) {
   const provider = h.getProvider(args?.agentType);
   const transport = getTargetTransport(h, provider);
   const dedupeKey = buildRecentSendKey(h, args, provider, text);
-  const historySessionId = getHistorySessionId(h, args);
   const _logSendSuccess = (method, targetAgent) => {
-    h.historyWriter.appendNewMessages(
-      targetAgent || provider?.type || getCurrentProviderType(h, "unknown_agent"),
-      [{ role: "user", content: text, receivedAt: Date.now() }],
-      void 0,
-      // title
-      args?.targetSessionId,
-      historySessionId
-    );
     return { success: true, sent: true, method, targetAgent };
   };
   if (isRecentDuplicateSend(dedupeKey)) {
@@ -41447,6 +41438,7 @@ var init_server_connection = __esm({
       userPlan = "free";
       iceServers = null;
       planLimits = null;
+      compatBlocked = false;
       constructor(options) {
         this.options = options;
       }
@@ -41557,6 +41549,7 @@ var init_server_connection = __esm({
           const message = JSON.parse(text);
           if (message.type === "auth_ok") {
             this.reconnectAttempts = 0;
+            this.compatBlocked = false;
             const payload = message.payload;
             this.userPlan = payload.plan || "free";
             this.iceServers = payload.iceServers || null;
@@ -41579,6 +41572,7 @@ var init_server_connection = __esm({
             LOG.info("Server", `     Run: adhdev daemon:upgrade
 `);
           } else if (message.type === "force_update_required") {
+            this.compatBlocked = true;
             const p = message.payload;
             LOG.error("Server", `
   \u26D4 Daemon v${this.options.daemonVersion} is no longer compatible.`);
@@ -41625,6 +41619,11 @@ var init_server_connection = __esm({
           }
           return;
         }
+        if (code === 4020 || this.compatBlocked) {
+          LOG.info("Server", `[ServerConn] \u26A0 Version compatibility blocked. Waiting for daemon update.`);
+          this.setState("disconnected");
+          return;
+        }
         if (code !== 1e3) {
           this.setState("disconnected");
           this.scheduleReconnect();
@@ -50076,13 +50075,13 @@ var init_adhdev_daemon = __esm({
     import_ws3 = require("ws");
     import_chalk2 = __toESM(require("chalk"));
     init_version();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.39" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.41" });
     ACTIVE_CHAT_POLL_STATUSES = /* @__PURE__ */ new Set([
       "generating",
       "waiting_approval",
       "starting"
     ]);
-    AdhdevDaemon = class {
+    AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
       localClients = /* @__PURE__ */ new Set();
@@ -50101,6 +50100,15 @@ var init_adhdev_daemon = __esm({
       running = false;
       localPort;
       ideType = "unknown";
+      pendingMandatoryUpdate = null;
+      mandatoryUpgradeInFlight = false;
+      static MANDATORY_UPDATE_BLOCKED_COMMANDS = /* @__PURE__ */ new Set([
+        "launch_ide",
+        "launch_cli",
+        "restart_ide",
+        "restart_session",
+        "session_host_restart_session"
+      ]);
       constructor() {
         this.localPort = 19222;
       }
@@ -50118,6 +50126,61 @@ var init_adhdev_daemon = __esm({
         const mode = this.getCliPresentationMode(sessionId);
         return mode === "chat" || mode === "terminal";
       }
+      getUpgradePackageName() {
+        return process.argv[1]?.includes("daemon-standalone") ? "@adhdev/daemon-standalone" : "adhdev";
+      }
+      hasBlockingSessionsForMandatoryUpdate() {
+        if (!this.components) return false;
+        const blocking = /* @__PURE__ */ new Set(["generating", "waiting_approval", "starting"]);
+        const states = this.components.instanceManager.collectAllStates();
+        for (const state of states) {
+          if (blocking.has(String(state.status || ""))) return true;
+          const childStates = "extensions" in state && Array.isArray(state.extensions) ? state.extensions : [];
+          if (childStates.length > 0) {
+            for (const child of childStates) {
+              if (blocking.has(String(child.status || ""))) return true;
+            }
+          }
+        }
+        return false;
+      }
+      async maybeApplyMandatoryUpdate(trigger) {
+        const pending = this.pendingMandatoryUpdate;
+        if (!pending || this.mandatoryUpgradeInFlight) return;
+        if (this.hasBlockingSessionsForMandatoryUpdate()) {
+          LOG.warn("Upgrade", `Mandatory update deferred (${trigger}) \u2014 active work in progress`);
+          return;
+        }
+        const pkgName = this.getUpgradePackageName();
+        this.mandatoryUpgradeInFlight = true;
+        try {
+          const { execSync: execSync8 } = await import("child_process");
+          const published = execSync8(`npm view ${pkgName}@${pending.targetVersion} version`, {
+            encoding: "utf-8",
+            timeout: 1e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          if (published !== pending.targetVersion) {
+            throw new Error(`Published version mismatch: expected ${pending.targetVersion}, got ${published || "unknown"}`);
+          }
+          LOG.warn("Upgrade", `Applying mandatory daemon update (${pending.reason}) \u2192 v${pending.targetVersion}`);
+          spawnDetachedDaemonUpgradeHelper({
+            packageName: pkgName,
+            targetVersion: pending.targetVersion,
+            parentPid: process.pid,
+            restartArgv: process.argv.slice(1),
+            cwd: process.cwd(),
+            sessionHostAppName: process.env.ADHDEV_SESSION_HOST_NAME || "adhdev"
+          });
+          setTimeout(() => {
+            LOG.warn("Upgrade", "Exiting daemon so mandatory detached upgrader can continue...");
+            process.exit(0);
+          }, 1500);
+        } catch (error48) {
+          this.mandatoryUpgradeInFlight = false;
+          LOG.error("Upgrade", `Mandatory auto-update failed: ${error48?.message || String(error48)}`);
+        }
+      }
       async buildChatTailUpdateForSubscription(subscription) {
         const result = await this.components.router.execute("read_chat", {
           targetSessionId: subscription.params.targetSessionId,
@@ -50558,6 +50621,8 @@ ${err?.stack || ""}`);
           }
           this.registerServerHandlers();
           this.serverConn.on("auth_ok", (msg) => {
+            this.pendingMandatoryUpdate = null;
+            this.mandatoryUpgradeInFlight = false;
             const serverNickname = msg.payload?.machineNickname;
             if (serverNickname === void 0) return;
             const nextNickname = typeof serverNickname === "string" && serverNickname.trim() ? serverNickname.trim() : null;
@@ -50568,6 +50633,16 @@ ${err?.stack || ""}`);
             LOG.info("Server", `[ServerConn] Synced machine nickname from server: ${nextNickname || "(cleared)"}`);
             this.statusReporter?.throttledReport();
           });
+          this.serverConn.on("force_update_required", (msg) => {
+            const payload = msg.payload;
+            this.pendingMandatoryUpdate = {
+              targetVersion: typeof payload.latest === "string" && payload.latest.trim() ? payload.latest.trim() : pkgVersion,
+              reason: typeof payload.reason === "string" && payload.reason.trim() ? payload.reason.trim() : "major_minor_mismatch",
+              minVersion: typeof payload.minVersion === "string" && payload.minVersion.trim() ? payload.minVersion.trim() : void 0
+            };
+            LOG.warn("Upgrade", `Mandatory daemon update required (${this.pendingMandatoryUpdate.reason})`);
+            void this.maybeApplyMandatoryUpdate("server-force-update");
+          });
           this.serverConn.onStateChange((state) => {
             if (state === "connected") {
               console.log(import_chalk2.default.green("  \u{1F4E1} Connected to ADHDev server"));
@@ -50591,6 +50666,7 @@ ${err?.stack || ""}`);
           this.statusReporter.startReporting();
           this.components.instanceManager.onEvent((event) => {
             this.statusReporter?.emitStatusEvent(event);
+            void this.maybeApplyMandatoryUpdate(`instance-event:${event.event}`);
           });
           this.running = true;
           process.on("SIGINT", () => this.stop());
@@ -50659,6 +50735,16 @@ ${err?.stack || ""}`);
         const cmdStart = Date.now();
         const source = msg.ipcWs ? "ext" : typeof msg.source === "string" && msg.source.trim() ? msg.source : "ws";
         try {
+          if (this.pendingMandatoryUpdate && _AdhdevDaemon.MANDATORY_UPDATE_BLOCKED_COMMANDS.has(cmd)) {
+            this.sendResult(msg, false, {
+              error: "A mandatory daemon update is pending. Finish current work and let the daemon update before starting a new session.",
+              code: "DAEMON_UPDATE_REQUIRED",
+              required: true,
+              latest: this.pendingMandatoryUpdate.targetVersion,
+              reason: this.pendingMandatoryUpdate.reason
+            });
+            return;
+          }
           if (source === "api" && !loadConfig().allowServerApiProxy) {
             this.sendResult(msg, false, {
               error: "Server API relay is disabled on this daemon. Enable it explicitly with `adhdev daemon:api enable`.",