@suzuke/agend 1.1.1 → 1.2.0

package/dist/fleet-manager.d.ts

@@ -14,7 +14,7 @@ export declare class FleetManager implements FleetContext {
     private daemons;
     fleetConfig: FleetConfig | null;
     adapter: ChannelAdapter | null;
-    routingTable: Map<number, RouteTarget>;
+    routingTable: Map<string, RouteTarget>;
     instanceIpcClients: Map<string, IpcClient>;
     scheduler: Scheduler | null;
     private configPath;
@@ -40,7 +40,7 @@ export declare class FleetManager implements FleetContext {
     /** Load fleet.yaml and build routing table */
     loadConfig(configPath: string): FleetConfig;
     /** Build topic routing table: { topicId -> RouteTarget } */
-    buildRoutingTable(): Map<number, RouteTarget>;
+    buildRoutingTable(): Map<string, RouteTarget>;
     getInstanceDir(name: string): string;
     getInstanceStatus(name: string): "running" | "stopped" | "crashed";
     startInstance(name: string, config: InstanceConfig, topicMode: boolean): Promise<void>;
@@ -69,7 +69,7 @@ export declare class FleetManager implements FleetContext {
     private notifyScheduleFailure;
     private handleScheduleCrud;
     /** Create a forum topic via the adapter. Returns the message_thread_id. */
-    createForumTopic(topicName: string): Promise<number>;
+    createForumTopic(topicName: string): Promise<number | string>;
     private deleteForumTopic;
     private topicCleanupTimer;
     private sessionPruneTimer;

package/dist/fleet-manager.js

@@ -24,6 +24,7 @@ import { TopicCommands, sanitizeInstanceName } 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";
 const TMUX_SESSION = "agend";
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
@@ -82,7 +83,7 @@ export class FleetManager {
             return table;
         for (const [name, inst] of Object.entries(this.fleetConfig.instances)) {
             if (inst.topic_id != null) {
-                table.set(inst.topic_id, {
+                table.set(String(inst.topic_id), {
                     kind: inst.general_topic ? "general" : "instance",
                     name,
                 });
@@ -124,25 +125,25 @@ export class FleetManager {
         const daemon = new Daemon(name, config, instanceDir, topicMode, backend, this.controlClient ?? undefined);
         await daemon.start();
         this.daemons.set(name, daemon);
-        daemon.on("restart_complete", (data) => {
+        daemon.on("restart_complete", safeHandler((data) => {
             this.eventLog?.insert(name, "context_rotation", data);
             this.logger.info({ name, ...data }, "Context restart completed");
-        });
+        }, this.logger, `daemon.restart_complete[${name}]`));
         const hangDetector = daemon.getHangDetector();
         if (hangDetector) {
-            hangDetector.on("hang", () => {
+            hangDetector.on("hang", safeHandler(async () => {
                 this.eventLog?.insert(name, "hang_detected", {});
                 this.logger.warn({ name }, "Instance appears hung");
-                this.sendHangNotification(name);
+                await this.sendHangNotification(name);
                 this.webhookEmitter?.emit("hang", name);
-            });
+            }, this.logger, `hangDetector[${name}]`));
         }
-        daemon.on("crash_loop", () => {
+        daemon.on("crash_loop", safeHandler(() => {
             this.eventLog?.insert(name, "crash_loop", {});
             this.logger.error({ name }, "Instance in crash loop — respawn paused");
             this.notifyInstanceTopic(name, `🔴 ${name} keeps crashing shortly after launch — respawn paused. Check rate limits or run \`agend fleet restart\`.`);
             this.setTopicIcon(name, "red");
-        });
+        }, this.logger, `daemon.crash_loop[${name}]`));
         this.setTopicIcon(name, "green");
         this.touchActivity(name);
     }
@@ -226,16 +227,16 @@ export class FleetManager {
             this.webhookEmitter = new WebhookEmitter(webhookConfigs, this.logger);
             this.logger.info({ count: webhookConfigs.length }, "Webhook emitter initialized");
         }
-        this.costGuard.on("warn", (instance, totalCents, limitCents) => {
+        this.costGuard.on("warn", safeHandler((instance, totalCents, limitCents) => {
             this.notifyInstanceTopic(instance, `⚠️ ${instance} cost: ${formatCents(totalCents)} / ${formatCents(limitCents)} (${Math.round(totalCents / limitCents * 100)}%)`);
             this.webhookEmitter?.emit("cost_warning", instance, { cost_cents: totalCents, limit_cents: limitCents });
-        });
-        this.costGuard.on("limit", (instance, totalCents, limitCents) => {
+        }, this.logger, "costGuard.warn"));
+        this.costGuard.on("limit", safeHandler(async (instance, totalCents, limitCents) => {
             this.notifyInstanceTopic(instance, `🛑 ${instance} daily limit ${formatCents(limitCents)} reached — pausing instance.`);
             this.eventLog?.insert(instance, "instance_paused", { reason: "cost_limit", cost_cents: totalCents });
             this.webhookEmitter?.emit("cost_limit", instance, { cost_cents: totalCents, limit_cents: limitCents });
-            this.stopInstance(instance).catch(err => this.logger.error({ err, instance }, "Failed to pause instance on cost limit"));
-        });
+            await this.stopInstance(instance);
+        }, this.logger, "costGuard.limit"));
         const summaryConfig = {
             ...DEFAULT_DAILY_SUMMARY,
             ...fleet.defaults?.daily_summary ?? {},
@@ -371,10 +372,10 @@ export class FleetManager {
             accessManager,
             inboxDir,
         });
-        this.adapter.on("message", (msg) => {
-            this.handleInboundMessage(msg);
-        });
-        this.adapter.on("callback_query", async (data) => {
+        this.adapter.on("message", safeHandler(async (msg) => {
+            await this.handleInboundMessage(msg);
+        }, this.logger, "adapter.message"));
+        this.adapter.on("callback_query", safeHandler(async (data) => {
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -395,28 +396,27 @@ export class FleetManager {
                 }
                 return;
             }
-        });
-        this.adapter.on("topic_closed", (data) => {
-            const tid = parseInt(data.threadId, 10);
+        }, this.logger, "adapter.callback_query"));
+        this.adapter.on("topic_closed", safeHandler(async (data) => {
             // Skip unbind if we archived this topic ourselves
-            if (this.archivedTopics.has(tid))
+            if (this.archivedTopics.has(data.threadId))
                 return;
-            this.topicCommands.handleTopicDeleted(tid);
-        });
+            await this.topicCommands.handleTopicDeleted(data.threadId);
+        }, this.logger, "adapter.topic_closed"));
         await this.topicCommands.registerBotCommands();
         await this.adapter.start();
         if (fleet.channel?.group_id) {
             this.adapter.setChatId(String(fleet.channel.group_id));
         }
-        this.adapter.on("started", (username) => {
-            this.logger.info(`Telegram bot @${username} polling`);
-        });
-        this.adapter.on("polling_conflict", ({ attempt, delay }) => {
+        this.adapter.on("started", safeHandler((username) => {
+            this.logger.info(`Bot @${username} polling`);
+        }, this.logger, "adapter.started"));
+        this.adapter.on("polling_conflict", safeHandler(({ attempt, delay }) => {
             this.logger.warn(`409 Conflict (attempt ${attempt}), retry in ${delay / 1000}s`);
-        });
-        this.adapter.on("handler_error", (err) => {
-            this.logger.warn({ err: err instanceof Error ? err.message : String(err) }, "Telegram handler error");
-        });
+        }, this.logger, "adapter.polling_conflict"));
+        this.adapter.on("handler_error", safeHandler((err) => {
+            this.logger.warn({ err: err instanceof Error ? err.message : String(err) }, "Adapter handler error");
+        }, this.logger, "adapter.handler_error"));
         this.startTopicCleanupPoller();
         // Prune stale external sessions every 5 minutes
         this.sessionPruneTimer = setInterval(() => {
@@ -438,7 +438,7 @@ export class FleetManager {
         try {
             await ipc.connect();
             this.instanceIpcClients.set(name, ipc);
-            ipc.on("message", (msg) => {
+            ipc.on("message", safeHandler(async (msg) => {
                 if (msg.type === "mcp_ready") {
                     // Register external sessions (sessionName differs from instance name)
                     const sessionName = msg.sessionName;
@@ -463,7 +463,7 @@ export class FleetManager {
                         this.sessionRegistry.set(sender, name);
                         this.logger.info({ sessionName: sender, instanceName: name }, "Registered external session");
                     }
-                    this.handleOutboundFromInstance(name, msg).catch(err => this.logger.error({ err }, "handleOutboundFromInstance error"));
+                    await this.handleOutboundFromInstance(name, msg);
                 }
                 else if (msg.type === "fleet_tool_status") {
                     this.handleToolStatusFromInstance(name, msg);
@@ -472,7 +472,7 @@ export class FleetManager {
                     msg.type === "fleet_schedule_update" || msg.type === "fleet_schedule_delete") {
                     this.handleScheduleCrud(name, msg);
                 }
-            });
+            }, this.logger, `ipc.message[${name}]`));
             // Ask daemon for any sessions that registered before we connected
             // (fixes race condition where mcp_ready was broadcast before fleet manager connected)
             ipc.send({ type: "query_sessions" });
@@ -497,7 +497,7 @@ export class FleetManager {
         return undefined;
     }
     async handleInboundMessage(msg) {
-        const threadId = msg.threadId ? parseInt(msg.threadId, 10) : undefined;
+        const threadId = msg.threadId || undefined;
         if (threadId == null) {
             // General topic: check for /status command
             if (await this.topicCommands.handleGeneralCommand(msg))
@@ -583,7 +583,7 @@ export class FleetManager {
         if (this.adapter && msg.chatId) {
             const threadId = msg.threadId ?? undefined;
             this.adapter.sendText(msg.chatId, `⏸ ${instanceName} has hit the weekly usage limit. Your message was not delivered. Limit resets automatically — check /status for details.`, { threadId })
-                .catch(e => this.logger.debug({ err: e }, "Failed to send rate limit notice"));
+                .catch(e => this.logger.warn({ err: e }, "Failed to send rate limit notice"));
         }
         this.logger.info({ instanceName }, "Blocked inbound message — weekly rate limit at 100%");
         return true;
@@ -695,13 +695,13 @@ export class FleetManager {
                     if (senderTopicId && !isExternalSender) {
                         this.adapter.sendText(String(groupId), `→ ${targetName}:\n${message}`, {
                             threadId: String(senderTopicId),
-                        }).catch(e => this.logger.debug({ err: e }, "Failed to post cross-instance notification"));
+                        }).catch(e => this.logger.warn({ err: e }, "Failed to post cross-instance notification"));
                     }
                     // Only post to target topic if target is an instance (not external session)
                     if (targetTopicId && !this.sessionRegistry.has(targetName)) {
                         this.adapter.sendText(String(groupId), `← ${senderLabel}:\n${message}`, {
                             threadId: String(targetTopicId),
-                        }).catch(e => this.logger.debug({ err: e }, "Failed to post cross-instance notification"));
+                        }).catch(e => this.logger.warn({ err: e }, "Failed to post cross-instance notification"));
                     }
                 }
                 this.logger.info(`✉ ${senderLabel} → ${targetName}: ${(message ?? "").slice(0, 100)}`);
@@ -737,14 +737,9 @@ export class FleetManager {
                 const question = args.question;
                 const context = args.context;
                 const body = context ? `${question}\n\nContext: ${context}` : question;
-                // Re-dispatch as send_to_instance with structured metadata
-                args.instance_name = targetName;
-                args.message = body;
-                args.request_kind = "query";
-                args.requires_reply = true;
-                args.task_summary = question.slice(0, 120);
-                // Recursively handle via the same switch (will hit send_to_instance case above)
-                return this.handleOutboundFromInstance(instanceName, { tool: "send_to_instance", args, requestId, fleetRequestId, senderSessionName });
+                // Re-dispatch as send_to_instance with structured metadata (new object to avoid mutating input)
+                const queryArgs = { ...args, instance_name: targetName, message: body, request_kind: "query", requires_reply: true, task_summary: question.slice(0, 120) };
+                return this.handleOutboundFromInstance(instanceName, { tool: "send_to_instance", args: queryArgs, requestId, fleetRequestId, senderSessionName });
             }
             case "delegate_task": {
                 const targetName = args.target_instance;
@@ -756,12 +751,8 @@ export class FleetManager {
                     body += `\n\nSuccess criteria: ${criteria}`;
                 if (context)
                     body += `\n\nContext: ${context}`;
-                args.instance_name = targetName;
-                args.message = body;
-                args.request_kind = "task";
-                args.requires_reply = true;
-                args.task_summary = task.slice(0, 120);
-                return this.handleOutboundFromInstance(instanceName, { tool: "send_to_instance", args, requestId, fleetRequestId, senderSessionName });
+                const taskArgs = { ...args, instance_name: targetName, message: body, request_kind: "task", requires_reply: true, task_summary: task.slice(0, 120) };
+                return this.handleOutboundFromInstance(instanceName, { tool: "send_to_instance", args: taskArgs, requestId, fleetRequestId, senderSessionName });
             }
             case "report_result": {
                 const targetName = args.target_instance;
@@ -773,12 +764,8 @@ export class FleetManager {
                 let body = summary;
                 if (artifacts)
                     body += `\n\nArtifacts: ${artifacts}`;
-                args.instance_name = targetName;
-                args.message = body;
-                args.request_kind = "report";
-                args.requires_reply = false;
-                args.task_summary = summary.slice(0, 120);
-                return this.handleOutboundFromInstance(instanceName, { tool: "send_to_instance", args, requestId, fleetRequestId, senderSessionName });
+                const reportArgs = { ...args, instance_name: targetName, message: body, request_kind: "report", requires_reply: false, task_summary: summary.slice(0, 120) };
+                return this.handleOutboundFromInstance(instanceName, { tool: "send_to_instance", args: reportArgs, requestId, fleetRequestId, senderSessionName });
             }
             // Phase 4: Capability discovery
             case "describe_instance": {
@@ -939,7 +926,7 @@ export class FleetManager {
                         ...(worktreePath ? { worktree_source: directory } : {}),
                     };
                     this.fleetConfig.instances[newInstanceName] = instanceConfig;
-                    this.routingTable.set(createdTopicId, { kind: "instance", name: newInstanceName });
+                    this.routingTable.set(String(createdTopicId), { kind: "instance", name: newInstanceName });
                     this.saveFleetConfig();
                     // Step c: Start instance
                     await this.startInstance(newInstanceName, instanceConfig, true);
@@ -954,12 +941,12 @@ export class FleetManager {
                 catch (err) {
                     // Rollback in reverse order
                     if (newInstanceName && this.daemons.has(newInstanceName)) {
-                        await this.stopInstance(newInstanceName).catch(() => { });
+                        await this.stopInstance(newInstanceName).catch(e => this.logger.error({ err: e, name: newInstanceName }, "Failed to stop instance during rollback"));
                     }
                     if (newInstanceName && this.fleetConfig?.instances[newInstanceName]) {
                         delete this.fleetConfig.instances[newInstanceName];
                         if (createdTopicId)
-                            this.routingTable.delete(createdTopicId);
+                            this.routingTable.delete(String(createdTopicId));
                         this.saveFleetConfig();
                     }
                     if (createdTopicId) {
@@ -1021,7 +1008,7 @@ export class FleetManager {
             this.adapter.sendText(chatId, text, { threadId }).then((sent) => {
                 const ipc = this.instanceIpcClients.get(instanceName);
                 ipc?.send({ type: "fleet_tool_status_ack", messageId: sent.messageId });
-            }).catch(e => this.logger.debug({ err: e }, "Failed to send tool status message"));
+            }).catch(e => this.logger.warn({ err: e }, "Failed to send tool status message"));
         }
     }
     // ===================== Scheduler =====================
@@ -1141,18 +1128,9 @@ export class FleetManager {
     }
     async deleteForumTopic(topicId) {
         try {
-            const groupId = this.fleetConfig?.channel?.group_id;
-            const botTokenEnv = this.fleetConfig?.channel?.bot_token_env;
-            if (!groupId || !botTokenEnv)
+            if (!this.adapter?.deleteTopic)
                 return;
-            const botToken = process.env[botTokenEnv];
-            if (!botToken)
-                return;
-            await fetch(`https://api.telegram.org/bot${botToken}/deleteForumTopic`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ chat_id: groupId, message_thread_id: topicId }),
-            });
+            await this.adapter.deleteTopic(topicId);
         }
         catch (err) {
             this.logger.warn({ err, topicId }, "Failed to delete forum topic during rollback");
@@ -1276,8 +1254,8 @@ export class FleetManager {
             this.instanceIpcClients.delete(name);
         }
         // Remove from routing table
-        if (config.topic_id) {
-            this.routingTable.delete(config.topic_id);
+        if (config.topic_id != null) {
+            this.routingTable.delete(String(config.topic_id));
         }
         // Remove from fleet config and save
         delete this.fleetConfig.instances[name];
@@ -1289,7 +1267,9 @@ export class FleetManager {
         const timer = setInterval(() => {
             try {
                 const data = JSON.parse(readFileSync(statusFile, "utf-8"));
-                this.costGuard?.updateCost(name, data.cost?.total_cost_usd ?? 0);
+                if (data.cost?.total_cost_usd != null) {
+                    this.costGuard?.updateCost(name, data.cost.total_cost_usd);
+                }
                 const rl = data.rate_limits;
                 if (rl) {
                     const prev = this.instanceRateLimits.get(name);
@@ -1435,7 +1415,8 @@ export class FleetManager {
             const topicId = config.topic_id;
             if (topicId == null || config.general_topic)
                 continue;
-            if (this.archivedTopics.has(topicId))
+            const topicIdStr = String(topicId);
+            if (this.archivedTopics.has(topicIdStr))
                 continue;
             const status = this.getInstanceStatus(name);
             if (status !== "running")
@@ -1446,7 +1427,7 @@ export class FleetManager {
             if (now - last < FleetManager.ARCHIVE_IDLE_MS)
                 continue;
             this.logger.info({ name, topicId, idleHours: Math.round((now - last) / 3600000) }, "Archiving idle topic");
-            this.archivedTopics.add(topicId);
+            this.archivedTopics.add(topicIdStr);
             this.setTopicIcon(name, "remove");
             await this.adapter.closeForumTopic(topicId);
         }