@songsid/agend 2.1.0 → 2.1.1-beta.10

package/dist/fleet-manager.js

@@ -42,6 +42,7 @@ import { handleSettingsRequest } from "./settings-api.js";
 import { setLocale, detectLocale, t } from "./locale.js";
 import { handleAgentRequest } from "./agent-endpoint.js";
 import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
+import { validateFleetConfig } from "./config-validator.js";
 import { readLastInboundAt } from "./daemon.js";
 import { clearPausedMarker } from "./pause-marker.js";
 import { getTmuxSession } from "./config.js";
@@ -88,6 +89,8 @@ const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
 const CLI_ENV_TTL_MS = 24 * 60 * 60 * 1000; // /model reads cached CLI env within 24h
 export class FleetManager {
     dataDir;
+    static signalTarget = null;
+    static sighupHandlerInstalled = false;
     children = new Map();
     lifecycle;
     /** @deprecated Use lifecycle.daemons — kept for backward compat */
@@ -112,6 +115,12 @@ export class FleetManager {
     instanceIpcClients = new Map();
     scheduler = null;
     configPath = "";
+    /** SIGHUPs received before startAll finishes are replayed once startup is safe. */
+    startupComplete = false;
+    /** Coalesces one or more SIGHUPs into at most one follow-up reconciliation. */
+    reloadPending = false;
+    /** A running reconciliation; only one may mutate lifecycle/config state at a time. */
+    reconcileInFlight = null;
     logger = createLogger("info");
     topicCommands;
     // sessionName → instanceName mapping for external sessions
@@ -174,11 +183,46 @@ export class FleetManager {
     viewToken = null;
     constructor(dataDir) {
         this.dataDir = dataDir;
+        FleetManager.signalTarget = this;
+        if (!FleetManager.sighupHandlerInstalled) {
+            process.on("SIGHUP", () => FleetManager.signalTarget?.handleSighup());
+            FleetManager.sighupHandlerInstalled = true;
+        }
         this.lifecycle = new InstanceLifecycle(this);
         this.topicCommands = new TopicCommands(this);
         this.topicArchiver = new TopicArchiver(this);
         this.statuslineWatcher = new StatuslineWatcher(this);
     }
+    handleSighup() {
+        this.logger.info("Received SIGHUP, hot-reloading config...");
+        if (!this.startupComplete) {
+            this.reloadPending = true;
+            this.logger.info("Fleet startup is still in progress — queued config reload");
+            return;
+        }
+        this.scheduleReconcile();
+    }
+    scheduleReconcile() {
+        if (this.reconcileInFlight) {
+            this.reloadPending = true;
+            this.logger.info("Config reconciliation already running — coalesced reload request");
+            return;
+        }
+        this.reloadPending = false;
+        this.reconcileInFlight = this.reconcileInstances()
+            .catch(err => this.logger.error({ err }, "SIGHUP config reload failed"))
+            .finally(() => {
+            this.reconcileInFlight = null;
+            if (this.reloadPending && this.startupComplete) {
+                this.scheduleReconcile();
+            }
+        });
+    }
+    finishStartup() {
+        this.startupComplete = true;
+        if (this.reloadPending)
+            this.scheduleReconcile();
+    }
     // ── ArchiverContext bridge ────────────────────────────────────────────
     lastActivityMs(name) {
         return this.lastActivity.get(name) ?? 0;
@@ -796,6 +840,8 @@ export class FleetManager {
     }
     /** Start all instances from fleet config */
     async startAll(configPath) {
+        FleetManager.signalTarget = this;
+        this.startupComplete = false;
         this.configPath = configPath;
         this.loadEnvFile();
         // Rotate fleet.log if oversized (before any logging)
@@ -1184,14 +1230,6 @@ export class FleetManager {
             this.checkForUpdates();
             this.updateCheckTimer = setInterval(() => this.checkForUpdates(), 24 * 60 * 60 * 1000);
         }, 60 * 60 * 1000);
-        // SIGHUP: hot-reload instance config (add/remove/restart instances)
-        const onSighup = () => {
-            this.logger.info("Received SIGHUP, hot-reloading config...");
-            this.reconcileInstances()
-                .catch(err => this.logger.error({ err }, "SIGHUP config reload failed"));
-            process.once("SIGHUP", onSighup);
-        };
-        process.once("SIGHUP", onSighup);
         const onRestart = () => {
             this.logger.info("Received SIGUSR2, initiating graceful restart...");
             this.restartInstances()
@@ -1213,6 +1251,10 @@ export class FleetManager {
             });
         };
         process.once("SIGUSR1", onFullRestart);
+        // A SIGHUP may arrive after the PID/general is available but before the
+        // rest of startup finishes. Replay one coalesced reload only after all
+        // startup-owned lifecycle work and signal handlers are in place.
+        this.finishStartup();
     }
     /**
      * Delete inbox files older than retentionDays (by mtime). Cleans the shared
@@ -4258,22 +4300,49 @@ When users create specialized instances, suggest these configurations:
         catch { /* missing / stale / corrupt */ }
         return null;
     }
-    /** Resolve the model currently configured for a fleet or ClassicBot instance. */
-    currentModelForInstance(instanceName) {
+    /**
+     * Resolve the effective model for a fleet or ClassicBot instance, plus where it
+     * came from. Single source of truth for `/model` and `/ctx` — precedence:
+     * per-instance → fleet defaults → classic channel → CLI's own default (from the
+     * cli-env probe cache) → unresolved.
+     */
+    resolveInstanceModel(instanceName) {
+        const done = (model, source, reason) => ({
+            model,
+            source,
+            reason,
+            // Make an inherited CLI default legible instead of the bare word "default".
+            display: source === "cli-default" ? `${model} (default)`
+                : source === "unresolved" ? `default (${reason ?? "unresolved"})`
+                    : model,
+        });
         const fleetInstance = this.fleetConfig?.instances[instanceName];
         if (fleetInstance) {
-            const fleetModel = fleetInstance.model ?? this.fleetConfig?.defaults?.model;
-            if (fleetModel?.trim())
-                return fleetModel.trim();
+            if (fleetInstance.model?.trim())
+                return done(fleetInstance.model.trim(), "instance");
+            const fleetDefault = this.fleetConfig?.defaults?.model;
+            if (fleetDefault?.trim())
+                return done(fleetDefault.trim(), "fleet-default");
         }
         const classic = this.classicChannels?.getAll().find(ch => ch.instanceName === instanceName);
         if (classic) {
             const classicModel = this.classicChannels?.getModel(classic.channelId, classic.adapterId, this.fleetConfig?.defaults?.model);
             if (classicModel?.trim())
-                return classicModel.trim();
-        }
-        const cachedModel = this.readCliEnv(this.backendNameForInstance(instanceName))?.currentModel;
-        return cachedModel?.trim() || "default";
+                return done(classicModel.trim(), "classic");
+        }
+        // Nothing configured → show what the CLI itself defaults to (kiro default_model,
+        // grok "Default model:", codex config.toml, agy settings.json), cached by the probe.
+        const cliEnv = this.readCliEnv(this.backendNameForInstance(instanceName));
+        const cachedModel = cliEnv?.currentModel;
+        if (cachedModel?.trim())
+            return done(cachedModel.trim(), "cli-default");
+        // Say WHY it's unresolved: no fresh probe yet vs. the CLI not exposing a default
+        // (e.g. claude-code's default is account-side, opencode's is provider-side).
+        return done("default", "unresolved", cliEnv ? "this CLI does not report a default" : "not probed yet");
+    }
+    /** Human-readable effective model, e.g. `auto (default)`. Used by /ctx. */
+    modelDisplayForInstance(instanceName) {
+        return this.resolveInstanceModel(instanceName).display;
     }
     modelChoiceLabel(option, currentModel) {
         const label = option.description ? `${option.label} — ${option.description}` : option.label;
@@ -4353,7 +4422,8 @@ When users create specialized instances, suggest these configurations:
             await data.respond(`No model list available for ${name}. Type \`/model <name>\` to set one directly.`);
             return;
         }
-        const currentModel = this.currentModelForInstance(name);
+        // Raw id for ✓-matching options; display resolves an inherited CLI default.
+        const { model: currentModel, display: currentDisplay } = this.resolveInstanceModel(name);
         const nonce = randomBytes(6).toString("hex");
         const choices = options.slice(0, 25).map(o => ({
             id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`,
@@ -4363,7 +4433,7 @@ When users create specialized instances, suggest these configurations:
         timer.unref?.();
         this.pendingModelSelects.set(nonce, { instanceName: name, model: "", userId: data.userId, channelId: data.channelId, timer, respond: data.respond });
         try {
-            await data.respondChoices(`Current model: **${currentModel}**\nSelect a new model:`, choices);
+            await data.respondChoices(`Current model: **${currentDisplay}**\nSelect a new model:`, choices);
         }
         catch (err) {
             this.pendingModelSelects.delete(nonce);
@@ -4382,7 +4452,7 @@ When users create specialized instances, suggest these configurations:
         if (options.length === 0) {
             return `No model list available for ${instanceName}. Use \`/model <name>\` to set one directly.`;
         }
-        const currentModel = this.currentModelForInstance(instanceName);
+        const { model: currentModel, display: currentDisplay } = this.resolveInstanceModel(instanceName);
         const nonce = randomBytes(6).toString("hex");
         const choices = options.slice(0, 25).map(o => ({
             id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`,
@@ -4402,7 +4472,7 @@ When users create specialized instances, suggest these configurations:
         timer.unref?.();
         this.pendingModelSelects.set(nonce, { instanceName, model: "", userId, channelId, timer, respond, adapter, adapterChatId: chatId, adapterThreadId: threadId });
         try {
-            const menuMessageId = await adapter.promptUser(chatId, `Current model: ${currentModel}\nSelect a new model:`, choices, { threadId });
+            const menuMessageId = await adapter.promptUser(chatId, `Current model: ${currentDisplay}\nSelect a new model:`, choices, { threadId });
             const pending = this.pendingModelSelects.get(nonce);
             if (pending)
                 pending.menuMessageId = menuMessageId;
@@ -4744,6 +4814,8 @@ When users create specialized instances, suggest these configurations:
         return t("classic.stopped");
     }
     async stopAll() {
+        this.startupComplete = false;
+        this.reloadPending = false;
         this.ipcStoppingInstances.add("__fleet_stopping__");
         sdNotify("STOPPING=1");
         if (this.watchdogTimer) {
@@ -4951,7 +5023,40 @@ When users create specialized instances, suggest these configurations:
         if (!this.configPath)
             return;
         const oldConfig = this.fleetConfig;
-        this.loadConfig(this.configPath);
+        const previousRawConfig = this.rawFleetConfig;
+        const previousRawDocument = this.rawFleetDocument;
+        const previousSavedSnapshot = this.savedFleetConfigSnapshot;
+        try {
+            this.loadConfig(this.configPath);
+        }
+        catch (err) {
+            this.fleetConfig = oldConfig;
+            this.rawFleetConfig = previousRawConfig;
+            this.rawFleetDocument = previousRawDocument;
+            this.savedFleetConfigSnapshot = previousSavedSnapshot;
+            throw err;
+        }
+        const validation = validateFleetConfig(this.rawFleetConfig);
+        const oldCount = Object.keys(oldConfig?.instances ?? {}).length;
+        const newCount = Object.keys(this.fleetConfig?.instances ?? {}).length;
+        const removedRatio = oldCount > 0 && newCount < oldCount
+            ? (oldCount - newCount) / oldCount
+            : 0;
+        const unsafeEmpty = oldCount > 0 && newCount === 0;
+        const unsafeBulkRemoval = removedRatio > 0.5;
+        if (!validation.valid || unsafeEmpty || unsafeBulkRemoval) {
+            this.fleetConfig = oldConfig;
+            this.rawFleetConfig = previousRawConfig;
+            this.rawFleetDocument = previousRawDocument;
+            this.savedFleetConfigSnapshot = previousSavedSnapshot;
+            this.logger.error({
+                oldCount,
+                newCount,
+                removedRatio,
+                validationErrors: validation.errors,
+            }, "Refusing unsafe fleet config reload; running configuration was kept");
+            return;
+        }
         this.routing.rebuild(this.fleetConfig);
         this.reregisterClassicChannels();
         this.scheduler?.reload();