@songsid/agend 2.1.0-beta.31 → 2.1.0-beta.33

package/dist/fleet-manager.js

@@ -122,6 +122,8 @@ export class FleetManager {
     lastActivity = new Map();
     /** Latest pane-derived execution snapshot reported by each daemon. */
     instanceStateCache = new Map();
+    /** CLI pane status overrides; daemon.pid alone only proves FleetManager lives. */
+    instanceProcessStatus = new Map();
     /** Instances currently being auto-paused by warm_cap, so concurrent checks don't double-evict. */
     warmCapEvicting = new Set();
     /** Per-instance tail keeps cross-instance and scheduled deliveries FIFO. */
@@ -369,6 +371,9 @@ export class FleetManager {
     getInstanceStatus(name) {
         if (this.lifecycle.isPaused(name))
             return "paused";
+        const processStatus = this.instanceProcessStatus.get(name);
+        if (processStatus)
+            return processStatus;
         const pidPath = join(this.getInstanceDir(name), "daemon.pid");
         if (!existsSync(pidPath))
             return "stopped";
@@ -410,6 +415,20 @@ export class FleetManager {
         if (state === "idle" && previous?.state !== "idle")
             this.enforceWarmCap();
     }
+    cacheInstanceProcessStatus(name, status) {
+        if (status === "running") {
+            this.instanceProcessStatus.delete(name);
+            return;
+        }
+        if (status !== "crashed" && status !== "stopped")
+            return;
+        this.instanceProcessStatus.set(name, status);
+        // Never display the last ready prompt as current execution state after its
+        // owning CLI process has exited.
+        this.instanceStateCache.delete(name);
+        for (const check of this.instanceIdleWaiters.get(name) ?? [])
+            check();
+    }
     /**
      * Fleet-wide warm cap: if more than `defaults.warm_cap` instances are running,
      * auto-pause the least-recently-active idle instances until back at the cap.
@@ -586,6 +605,7 @@ export class FleetManager {
             }
             this.ensureGeneralInstructions(config.working_directory, config.backend);
         }
+        this.instanceProcessStatus.delete(name);
         await this.lifecycle.start(name, config, topicMode);
         // Auto-connect IPC — daemon.start() ensures socket is ready before resolving
         await this.connectIpcToInstance(name);
@@ -688,22 +708,53 @@ export class FleetManager {
     async stopInstance(name) {
         this.failoverActive.delete(name);
         this.instanceStateCache.delete(name);
+        this.instanceProcessStatus.delete(name);
         this.lastDeliveryAt.delete(name);
         return this.lifecycle.stop(name);
     }
     /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
-    async restartSingleInstance(name) {
+    async restartSingleInstance(name, opts) {
         if (this.configPath) {
             this.loadConfig(this.configPath);
             this.routing.rebuild(this.fleetConfig);
             this.reregisterClassicChannels();
         }
         const config = this.fleetConfig?.instances[name];
-        if (!config)
-            throw new Error(`Instance not found: ${name}`);
-        await this.stopInstance(name);
-        const topicMode = this.fleetConfig?.channel?.mode === "topic";
-        await this.startInstance(name, config, topicMode ?? false);
+        if (config) {
+            await this.stopInstance(name);
+            if (opts?.freshStart)
+                this.writeFreshStartMarker(name);
+            const topicMode = this.fleetConfig?.channel?.mode === "topic";
+            await this.startInstance(name, config, topicMode ?? false);
+            return;
+        }
+        // Classic instance fallback
+        const channelId = this.classicChannels?.getChannelIdByInstance(name);
+        if (channelId) {
+            const fleetBackend = this.fleetConfig?.defaults?.backend;
+            const adapterId = this.classicChannels.getAdapterIdByInstance(name);
+            await this.stopInstance(name);
+            await new Promise(r => setTimeout(r, 1000)); // let tmux clean up
+            if (opts?.freshStart)
+                this.writeFreshStartMarker(name);
+            await this.startClassicInstance(name, this.classicChannels.getBackendByInstance(name, fleetBackend), this.classicChannels.getPreTaskCommand(channelId, adapterId), this.classicChannels.getModel(channelId, adapterId, this.fleetConfig?.defaults?.model), this.classicChannels.getAutoPauseAfter(channelId, adapterId, this.fleetConfig?.defaults?.auto_pause_after));
+            return;
+        }
+        throw new Error(`Instance not found: ${name}`);
+    }
+    /**
+     * Mark an instance so its next daemon start skips session resume. Written AFTER
+     * stop (survives the old daemon's cleanup) and BEFORE start so the respawn reads
+     * it — reuses the crash-state → resumeDisabled path from crash-loop recovery.
+     * One-shot: the daemon deletes it on startup.
+     */
+    writeFreshStartMarker(name) {
+        try {
+            writeFileSync(join(this.getInstanceDir(name), "crash-state.json"), JSON.stringify({ resumeDisabled: true, reason: "pty_error_restart" }));
+        }
+        catch (err) {
+            this.logger.warn({ err, name }, "freshStart: failed to write crash-state marker");
+        }
     }
     /** Load .env file from data dir into process.env */
     loadEnvFile() {
@@ -1328,7 +1379,7 @@ export class FleetManager {
         // Handle classic bot slash commands (/start, /stop, /chat, /compact, /save, /load)
         this.adapter.on("slash_command", safeHandler(async (data) => {
             if (data.command === "start") {
-                await this.handleClassicStartSlash(data, adapterId, this.adapter);
+                await this.handleClassicStartSlash(data, adapterId);
             }
             else if (data.command === "stop") {
                 const reply = await this.handleClassicStop(data.channelId, adapterId);
@@ -1611,7 +1662,7 @@ export class FleetManager {
         // Slash commands: classic bot + admin commands
         adapter.on("slash_command", safeHandler(async (data) => {
             if (data.command === "start") {
-                await this.handleClassicStartSlash(data, adapterId, adapter);
+                await this.handleClassicStartSlash(data, adapterId);
             }
             else if (data.command === "stop") {
                 const reply = await this.handleClassicStop(data.channelId, adapterId);
@@ -1876,8 +1927,14 @@ export class FleetManager {
                 else if (msg.type === "fleet_set_description") {
                     this.handleSetDescription(name, msg);
                 }
+                else if (msg.type === "instance_process_state") {
+                    this.cacheInstanceProcessStatus(name, msg.status);
+                }
                 else if (msg.type === "instance_state" || msg.type === "instance_state_response") {
                     this.cacheInstanceExecutionState(name, msg);
+                    if (msg.type === "instance_state_response") {
+                        this.cacheInstanceProcessStatus(name, msg.processStatus);
+                    }
                 }
             }, this.logger, `ipc.message[${name}]`));
             // Ask daemon for any sessions that registered before we connected
@@ -4015,13 +4072,25 @@ When users create specialized instances, suggest these configurations:
                 const inboxDir = join(getAgendHome(), "workspaces", instanceName, "inbox");
                 mkdirSync(inboxDir, { recursive: true });
                 const dest = join(inboxDir, basename(tmpPath));
+                // Copy to destination — failure means this attachment is skipped
                 try {
-                    renameSync(tmpPath, dest);
-                }
-                catch {
                     copyFileSync(tmpPath, dest);
+                }
+                catch (copyErr) {
+                    try {
+                        unlinkSync(dest);
+                    }
+                    catch { } // clean partial
+                    this.logger.warn({ err: copyErr.message, instanceName, dest }, "Attachment copy failed — skipping");
+                    continue;
+                }
+                // Cleanup source — failure is non-fatal (dest already valid)
+                try {
                     unlinkSync(tmpPath);
                 }
+                catch (cleanupErr) {
+                    this.logger.debug({ tmpPath, err: cleanupErr.message }, "Orphan tmp not cleaned");
+                }
                 const savedKind = att.kind === "sticker" ? "photo" : att.kind;
                 paths.push(dest);
                 if (paths.length === 1)
@@ -4139,11 +4208,16 @@ When users create specialized instances, suggest these configurations:
             return undefined;
         return t("classic.backend_not_installed", backend, installation.binary, installation.install);
     }
-    /** Handle Discord's optional static slash choice, warning before a likely startup failure. */
-    async handleClassicStartSlash(data, adapterId, adapter) {
+    /** Handle Discord's required static slash choice, warning before a likely startup failure. */
+    async handleClassicStartSlash(data, adapterId) {
         const requestedBackend = typeof data.options?.backend === "string" ? data.options.backend : undefined;
         if (!requestedBackend) {
-            await this.beginClassicBackendSelection(data, adapter);
+            // beta.31 made this option required. Discord can briefly retain the old
+            // command schema client-side, however, so stale clients may still submit
+            // `/start` without it. Do not resurrect the legacy 60-second component
+            // menu in that case: fail immediately and make the user invoke the newly
+            // registered command, which guarantees an explicit backend choice.
+            await data.respond(t("classic.backend_required"));
             return;
         }
         const warning = this.getMissingBackendWarning(requestedBackend);