@songsid/agend 2.1.0-beta.23 → 2.1.0-beta.25

package/dist/fleet-manager.js

@@ -24,13 +24,13 @@ import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { Scheduler } from "./scheduler/index.js";
 import { DEFAULT_SCHEDULER_CONFIG } from "./scheduler/index.js";
-import { TopicCommands, saveCommandForBackend, parseSaveFilename, SAVE_FILENAME_RE, SAVE_UNSUPPORTED_MSG } from "./topic-commands.js";
+import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, SAVE_FILENAME_RE, SAVE_UNSUPPORTED_MSG } from "./topic-commands.js";
 import { DailySummary } from "./daily-summary.js";
 import { WebhookEmitter } from "./webhook-emitter.js";
 import { TmuxControlClient } from "./tmux-control.js";
 import { safeHandler } from "./safe-async.js";
 import { RoutingEngine } from "./routing-engine.js";
-import { InstanceLifecycle } from "./instance-lifecycle.js";
+import { InstanceLifecycle, BACKEND_INSTALLATION_INFO, checkBinaryInstalled, } from "./instance-lifecycle.js";
 import { TopicArchiver } from "./topic-archiver.js";
 import { StatuslineWatcher } from "./statusline-watcher.js";
 import { outboundHandlers } from "./outbound-handlers.js";
@@ -40,6 +40,7 @@ import { handleSettingsRequest } from "./settings-api.js";
 import { setLocale, detectLocale, t } from "./locale.js";
 import { handleAgentRequest } from "./agent-endpoint.js";
 import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend } from "./classic-channel-manager.js";
+import { readLastInboundAt } from "./daemon.js";
 import { getTmuxSession } from "./config.js";
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
@@ -251,6 +252,41 @@ export class FleetManager {
         return this.classicChannels?.getInstanceByChannel(channelId, adapterId)
             ?? this.routing.resolve(channelId)?.name;
     }
+    async handlePauseWakeSlash(data, adapterId) {
+        const action = data.command;
+        const classicName = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+        if (classicName) {
+            if (!this.classicChannels?.isAdmin(data.userId)) {
+                await data.respond(t("permission.denied"));
+                return;
+            }
+            await data.respond(await this.topicCommands.runPauseWake(classicName, action));
+            return;
+        }
+        if (!this.isFleetAdmin(data.userId, adapterId)) {
+            await data.respond(t("permission.denied"));
+            return;
+        }
+        const route = this.routing.resolve(data.channelId);
+        if (!route) {
+            await data.respond(t("classic.no_agent"));
+            return;
+        }
+        let target = route.name;
+        if (route.kind === "general") {
+            const requested = typeof data.options?.instance === "string" ? data.options.instance : undefined;
+            if (!requested) {
+                await data.respond(t(`${action}.usage`));
+                return;
+            }
+            if (!this.fleetConfig?.instances[requested]) {
+                await data.respond(t("instance.not_found", requested));
+                return;
+            }
+            target = requested;
+        }
+        await data.respond(await this.topicCommands.runPauseWake(target, action));
+    }
     /** Get the adapter bound to an instance, falling back to primary adapter */
     getAdapterForInstance(name) {
         const worldId = this.instanceWorldBinding.get(name);
@@ -345,6 +381,19 @@ export class FleetManager {
             throw new Error(`Instance '${instanceName}' IPC is unavailable`);
         ipc.send(payload);
     }
+    /** Fleet admin is an explicit config allowlist entry, not merely an open/paired user. */
+    isFleetAdmin(userId, adapterId) {
+        const allowed = this.getChannelConfig(adapterId)?.access?.allowed_users ?? [];
+        return allowed.some(entry => String(entry) === String(userId));
+    }
+    async changeInstancePauseState(name, action) {
+        if (action === "wake") {
+            await this.lifecycle.wake(name, 30_000);
+            return "awake";
+        }
+        await this.lifecycle.pause(name);
+        return this.lifecycle.isPaused(name) ? "paused" : "not_idle";
+    }
     async startInstance(name, config, topicMode) {
         if (config.general_topic) {
             this.ensureGeneralInstructions(config.working_directory, config.backend);
@@ -1038,19 +1087,15 @@ 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") {
-                const requestedBackend = typeof data.options?.backend === "string" ? data.options.backend : undefined;
-                if (requestedBackend) {
-                    const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId, adapterId, requestedBackend);
-                    await data.respond(reply);
-                }
-                else {
-                    await this.beginClassicBackendSelection(data, this.adapter);
-                }
+                await this.handleClassicStartSlash(data, adapterId, this.adapter);
             }
             else if (data.command === "stop") {
                 const reply = await this.handleClassicStop(data.channelId, adapterId);
                 await data.respond(reply);
             }
+            else if (data.command === "pause" || data.command === "wake") {
+                await this.handlePauseWakeSlash(data, adapterId);
+            }
             else if (data.command === "chat") {
                 const text = data.text ?? "";
                 if (!text) {
@@ -1325,19 +1370,15 @@ export class FleetManager {
         // Slash commands: classic bot + admin commands
         adapter.on("slash_command", safeHandler(async (data) => {
             if (data.command === "start") {
-                const requestedBackend = typeof data.options?.backend === "string" ? data.options.backend : undefined;
-                if (requestedBackend) {
-                    const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId, adapterId, requestedBackend);
-                    await data.respond(reply);
-                }
-                else {
-                    await this.beginClassicBackendSelection(data, adapter);
-                }
+                await this.handleClassicStartSlash(data, adapterId, adapter);
             }
             else if (data.command === "stop") {
                 const reply = await this.handleClassicStop(data.channelId, adapterId);
                 await data.respond(reply);
             }
+            else if (data.command === "pause" || data.command === "wake") {
+                await this.handlePauseWakeSlash(data, adapterId);
+            }
             else if (data.command === "chat") {
                 const text = data.text ?? "";
                 if (!text) {
@@ -1897,6 +1938,20 @@ export class FleetManager {
                     await msgAdapter?.sendText(chatId, reply);
                     return;
                 }
+                const pauseWake = parsePauseWakeCommand(text);
+                if (pauseWake) {
+                    if (!this.classicChannels.isAdmin(msg.userId)) {
+                        await msgAdapter?.sendText(chatId, t("permission.denied"));
+                        return;
+                    }
+                    const name = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!name) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
+                        return;
+                    }
+                    await msgAdapter?.sendText(chatId, await this.topicCommands.runPauseWake(name, pauseWake.action));
+                    return;
+                }
                 // Handle /compact command (admin only)
                 if (text === "/compact" || text.startsWith("/compact@")) {
                     if (!this.classicChannels.isAdmin(msg.userId)) {
@@ -3829,6 +3884,33 @@ When users create specialized instances, suggest these configurations:
             return t("classic.topic_bound");
         return undefined;
     }
+    isBackendInstalled(backend) {
+        const installation = BACKEND_INSTALLATION_INFO[backend];
+        return !!installation && checkBinaryInstalled(installation.binary);
+    }
+    getMissingBackendWarning(backend) {
+        if (!backend)
+            return undefined;
+        const installation = BACKEND_INSTALLATION_INFO[backend];
+        if (!installation || this.isBackendInstalled(backend))
+            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) {
+        const requestedBackend = typeof data.options?.backend === "string" ? data.options.backend : undefined;
+        if (!requestedBackend) {
+            await this.beginClassicBackendSelection(data, adapter);
+            return;
+        }
+        const warning = this.getMissingBackendWarning(requestedBackend);
+        // Keep the deferred ephemeral response useful even if daemon startup later
+        // fails because the executable is absent. This is advisory, not a gate.
+        if (warning)
+            await data.respond(warning);
+        const reply = await this.handleClassicStart(data.channelId, data.channelName, data.userId, data.guildId, adapterId, requestedBackend);
+        await data.respond(warning ? `${warning}\n\n${reply}` : reply);
+    }
     /** Present platform-native backend choices, then start on selection or timeout. */
     async beginClassicBackendSelection(data, adapter) {
         const adapterId = adapter.id;
@@ -3840,7 +3922,7 @@ When users create specialized instances, suggest these configurations:
         const nonce = randomBytes(6).toString("hex");
         const choices = getClassicBackendChoices().map(choice => ({
             id: `${CLASSIC_BACKEND_CALLBACK_PREFIX}${nonce}:${choice.id}`,
-            label: choice.label,
+            label: `${this.isBackendInstalled(choice.id) ? "✅" : "❌"} ${choice.label}`,
         }));
         const complete = data.respondChoices
             ? async (text) => { await data.respond(text); }
@@ -3908,8 +3990,17 @@ When users create specialized instances, suggest these configurations:
         this.pendingClassicStarts.delete(nonce);
         clearTimeout(pending.timer);
         const selectedBackend = isSelectableClassicBackend(backend) ? backend : undefined;
+        const effectiveBackend = selectedBackend
+            ?? this.classicChannels?.getDefaults().backend
+            ?? this.fleetConfig?.defaults?.backend
+            ?? "claude-code";
+        const warning = this.getMissingBackendWarning(effectiveBackend);
+        // Show the warning before starting so it survives a missing-binary startup
+        // failure. The selected backend is still attempted as requested.
+        if (warning)
+            await pending.complete(warning, pending.messageId);
         const reply = await this.handleClassicStart(pending.channelId, pending.channelName, pending.userId, pending.guildId, pending.adapterId, selectedBackend);
-        await pending.complete(reply, pending.messageId);
+        await pending.complete(warning ? `${warning}\n\n${reply}` : reply, pending.messageId);
     }
     /** Start a classic channel instance with lightweight config */
     async startClassicInstance(instanceName, backend, preTaskCommand, model) {
@@ -4533,8 +4624,27 @@ When users create specialized instances, suggest these configurations:
             // Fleet API (enriched for agent board)
             if (req.method === "GET" && req.url === "/api/fleet") {
                 const sysInfo = this.getSysInfo();
-                const enriched = sysInfo.instances.map(inst => {
+                const fleetInstances = sysInfo.instances.map(inst => ({ ...inst, classic: false }));
+                const fleetNames = new Set(fleetInstances.map(inst => inst.name));
+                const classicInstances = (this.classicChannels?.getAll() ?? [])
+                    .filter(channel => !fleetNames.has(channel.instanceName))
+                    .map(channel => ({
+                    name: channel.instanceName,
+                    status: this.getInstanceStatus(channel.instanceName),
+                    state: this.getInstanceExecutionState(channel.instanceName),
+                    ipc: this.instanceIpcClients.has(channel.instanceName),
+                    costCents: this.costGuard?.getDailyCostCents(channel.instanceName) ?? 0,
+                    rateLimits: this.statuslineWatcher.getRateLimits(channel.instanceName) ?? null,
+                    classic: true,
+                    classicName: channel.name,
+                    channelId: channel.channelId,
+                    adapterId: channel.adapterId ?? null,
+                }));
+                const enriched = [...fleetInstances, ...classicInstances].map(inst => {
                     const config = this.fleetConfig?.instances[inst.name];
+                    const backend = inst.classic
+                        ? this.classicChannels?.getBackendByInstance(inst.name, this.fleetConfig?.defaults.backend) ?? "claude-code"
+                        : config?.backend ?? "claude-code";
                     // Find claimed tasks for this instance
                     let currentTask = null;
                     try {
@@ -4547,11 +4657,13 @@ When users create specialized instances, suggest these configurations:
                     }
                     return {
                         ...inst,
-                        description: config?.description ?? null,
-                        backend: config?.backend ?? "claude-code",
+                        description: config?.description ?? ("classicName" in inst ? inst.classicName : null),
+                        backend,
                         tool_set: config?.tool_set ?? "full",
                         general_topic: config?.general_topic ?? false,
-                        lastActivity: this.lastActivityMs(inst.name) || null,
+                        // User activity is persisted by the daemon, so both the board and
+                        // auto-pause retain an accurate age across fleet restarts.
+                        lastActivity: (readLastInboundAt(this.getInstanceDir(inst.name)) ?? this.lastActivityMs(inst.name)) || null,
                         currentTask,
                         idle: this.getInstanceIdle(inst.name),
                         state: this.getInstanceExecutionState(inst.name),