@songsid/agend 0.0.1

package/dist/fleet-manager.d.ts

@@ -0,0 +1,212 @@
+import type { FleetConfig, InstanceConfig } from "./types.js";
+import { type RouteTarget } from "./fleet-context.js";
+import { EventLog } from "./event-log.js";
+import { AdapterWorld } from "./adapter-world.js";
+import { CostGuard } from "./cost-guard.js";
+import { IpcClient } from "./channel/ipc-bridge.js";
+import type { ChannelAdapter } from "./channel/types.js";
+import { type Logger } from "./logger.js";
+import { Scheduler } from "./scheduler/index.js";
+import type { FleetContext } from "./fleet-context.js";
+import { TmuxControlClient } from "./tmux-control.js";
+import { RoutingEngine } from "./routing-engine.js";
+import { InstanceLifecycle, type LifecycleContext } from "./instance-lifecycle.js";
+import { type ArchiverContext } from "./topic-archiver.js";
+import { type StatuslineWatcherContext } from "./statusline-watcher.js";
+import { type OutboundContext } from "./outbound-handlers.js";
+import { type AgentEndpointContext } from "./agent-endpoint.js";
+import { ClassicChannelManager } from "./classic-channel-manager.js";
+export declare function resolveReplyThreadId(argsThreadId: unknown, instanceConfig?: InstanceConfig): string | undefined;
+export declare class FleetManager implements FleetContext, LifecycleContext, ArchiverContext, StatuslineWatcherContext, OutboundContext, AgentEndpointContext {
+    dataDir: string;
+    private children;
+    readonly lifecycle: InstanceLifecycle;
+    /** @deprecated Use lifecycle.daemons — kept for backward compat */
+    get daemons(): Map<string, import("./daemon.js").Daemon>;
+    fleetConfig: FleetConfig | null;
+    adapter: ChannelAdapter | null;
+    readonly worlds: Map<string, AdapterWorld>;
+    readonly adapters: Map<string, ChannelAdapter>;
+    /** Track which world each instance is bound to */
+    private instanceWorldBinding;
+    private accessManager;
+    /** Primary world (first adapter) — used for fleet-level notifications */
+    get primaryWorld(): AdapterWorld | undefined;
+    readonly routing: RoutingEngine;
+    get routingTable(): Map<string, RouteTarget>;
+    instanceIpcClients: Map<string, IpcClient>;
+    scheduler: Scheduler | null;
+    private configPath;
+    logger: Logger;
+    private topicCommands;
+    sessionRegistry: Map<string, string>;
+    eventLog: EventLog | null;
+    costGuard: CostGuard | null;
+    private statuslineWatcher;
+    private dailySummary;
+    private webhookEmitter;
+    private topicIcons;
+    private lastActivity;
+    private lastInboundUser;
+    private topicArchiver;
+    controlClient: TmuxControlClient | null;
+    classicChannels: ClassicChannelManager | null;
+    private failoverActive;
+    private healthServer;
+    private startedAt;
+    private mirrorBuffer;
+    private mirrorTimer;
+    private sseClients;
+    private webToken;
+    constructor(dataDir: string);
+    lastActivityMs(name: string): number;
+    webhookEmit(event: string, name: string, data?: Record<string, unknown>): void;
+    getSysInfo(): import("./fleet-context.js").SysInfo;
+    /** Load fleet.yaml and build routing table */
+    loadConfig(configPath: string): FleetConfig;
+    /** Build topic routing table: { topicId -> RouteTarget } */
+    buildRoutingTable(): Map<string, RouteTarget>;
+    /** Re-register classic channels after routing rebuild (rebuild clears the table) */
+    private reregisterClassicChannels;
+    getInstanceDir(name: string): string;
+    /** Get the adapter bound to an instance, falling back to primary adapter */
+    getAdapterForInstance(name: string): ChannelAdapter | null;
+    /** Get the world for an instance */
+    getWorldForInstance(name: string): AdapterWorld | undefined;
+    /** Get channel config for a specific adapter (by id), falling back to primary */
+    getChannelConfig(adapterId?: string): import("./types.js").ChannelConfig | undefined;
+    /** Get the group_id for an instance's bound adapter */
+    getGroupIdForInstance(name: string): string;
+    /** Bind an instance to a specific world. fromInbound=true skips general_topic to prevent overwrite. */
+    bindInstanceAdapter(name: string, adapterId: string, fromInbound?: boolean): void;
+    getInstanceStatus(name: string): "running" | "stopped" | "crashed";
+    startInstance(name: string, config: InstanceConfig, topicMode: boolean): Promise<void>;
+    /**
+     * Start instances with configurable concurrency and stagger delay.
+     * Instances sharing the same working_directory are serialized within a group
+     * to avoid config file races. Stagger delay is group-to-group, not instance-to-instance.
+     * TODO: per-instance startup timeout (existing issue, not introduced here)
+     */
+    private startInstancesWithConcurrency;
+    stopInstance(name: string): Promise<void>;
+    /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
+    restartSingleInstance(name: string): Promise<void>;
+    /** Load .env file from data dir into process.env */
+    private loadEnvFile;
+    /** Start all instances from fleet config */
+    startAll(configPath: string): Promise<void>;
+    /** Start the shared channel adapter(s) for topic mode */
+    private startSharedAdapter;
+    /** Start the primary adapter (backward-compatible, sets this.adapter) */
+    private startSingleAdapter;
+    /** Start an additional (non-primary) adapter */
+    private startAdditionalAdapter;
+    /** Connect IPC to a single instance with all handlers */
+    connectIpcToInstance(name: string): Promise<void>;
+    /** Handle inbound message — transcribe voice if present, then route */
+    private findGeneralInstance;
+    private handleInboundMessage;
+    /** Handle outbound tool calls from a daemon instance */
+    /** Warn (but don't block) when rate limits are high. 30-min debounce per instance. */
+    private rateLimitWarnedAt;
+    private warnIfRateLimited;
+    /** Handle outbound tool calls from a daemon instance */
+    private handleOutboundFromInstance;
+    /** Handle tool status update from a daemon instance */
+    private handleToolStatusFromInstance;
+    private handleScheduleTrigger;
+    private notifySourceTopic;
+    private notifyScheduleFailure;
+    private handleScheduleCrud;
+    private handleDecisionCrud;
+    /** Resolve display name for an instance, fallback to instance name. */
+    resolveDisplayName(instanceName: string): string;
+    private handleSetDisplayName;
+    private handleSetDescription;
+    handleScheduleCrudHttp(instance: string, op: string, args: Record<string, unknown>): Promise<unknown>;
+    handleDecisionCrudHttp(instance: string, op: string, args: Record<string, unknown>): Promise<unknown>;
+    handleTaskCrudHttp(instance: string, args: Record<string, unknown>): Promise<unknown>;
+    handleSetDisplayNameHttp(instance: string, name: string): Promise<unknown>;
+    handleSetDescriptionHttp(instance: string, description: string): Promise<unknown>;
+    private summarizeToolCall;
+    private handleTaskCrud;
+    /** Create a forum topic via the adapter. Returns the message_thread_id. */
+    createForumTopic(topicName: string, adapterId?: string): Promise<number | string>;
+    deleteForumTopic(topicId: number | string): Promise<void>;
+    private topicCleanupTimer;
+    private sessionPruneTimer;
+    private classicReloadTimer;
+    private botUserId;
+    /** Periodically check if bound topics still exist */
+    private startTopicCleanupPoller;
+    /** Save fleet config back to fleet.yaml */
+    saveFleetConfig(): void;
+    removeInstance(name: string): Promise<void>;
+    startStatuslineWatcher(name: string): void;
+    reactMessageStatus(chatId: string, messageId: string, emoji: string): void;
+    private static FAILOVER_TRIGGER_PCT;
+    private static FAILOVER_RECOVER_PCT;
+    checkModelFailover(name: string, fiveHourPct: number): void;
+    notifyInstanceTopic(instanceName: string, text: string): void;
+    queueMirrorMessage(text: string): void;
+    /** Push an SSE event to all connected Web UI clients. */
+    emitSseEvent(event: string, data: unknown): void;
+    listClaimedTasks(assignee: string): Array<{
+        id: string;
+        title: string;
+    }>;
+    sendHangNotification(instanceName: string): Promise<void>;
+    private static INSTRUCTIONS_FILENAME;
+    private static GENERAL_INSTRUCTIONS;
+    /** Ensure the general instance has its project instructions file + knowledge */
+    private ensureGeneralInstructions;
+    /** Copy src/general-knowledge/*.md to the general instance's steering dir */
+    private syncGeneralKnowledge;
+    /** Fetch forum topic icon stickers and pick emoji IDs for each state */
+    private resolveTopicIcons;
+    /** Set topic icon based on instance state */
+    setTopicIcon(instanceName: string, state: "green" | "blue" | "red" | "remove"): void;
+    /** Track activity timestamp for idle detection */
+    touchActivity(instanceName: string): void;
+    /** Start periodic idle archive checker */
+    private clearStatuslineWatchers;
+    /** Handle a message in a classic channel: log it, forward only /chat messages */
+    private handleClassicChannelMessage;
+    /** Download photo or document attachment to classic instance workspace inbox. Returns { path, kind } or undefined. */
+    private saveClassicAttachment;
+    /** Forward a message to a classic channel instance with chat log context */
+    private forwardToClassicInstance;
+    /** Paste raw text directly to a classic instance's CLI (no [user:] wrapping) */
+    private pasteRawToClassicInstance;
+    /** Read recent chat log (last ~50 lines) for agent context */
+    private getRecentChatLog;
+    /** Start a classic channel instance with lightweight config */
+    private startClassicInstance;
+    /** Handle /start slash command — register classic channel */
+    handleClassicStart(channelId: string, channelName: string, userId: string, guildId?: string): Promise<string>;
+    /** Handle /stop slash command — unregister classic channel */
+    handleClassicStop(channelId: string): Promise<string>;
+    stopAll(): Promise<void>;
+    /**
+     * Prune stale external sessions by re-querying each daemon for live sessions.
+     * Sessions in the registry that are no longer reported by any daemon are removed.
+     */
+    pruneStaleExternalSessions(): Promise<number>;
+    /**
+     * Graceful shutdown for full reload: wait for idle, notify, then stop everything.
+     * The caller is expected to exit the process after this resolves.
+     */
+    gracefulShutdownForReload(): Promise<void>;
+    /**
+     * Graceful restart: wait for all instances to be idle, then stop and start them.
+     */
+    /**
+     * Hot-reload: re-read fleet.yaml and reconcile running instances.
+     * Starts new, stops removed, restarts modified instances.
+     * Fleet-level config (access, cost_guard, etc.) requires /restart to take effect.
+     */
+    private reconcileInstances;
+    restartInstances(): Promise<void>;
+    private startHealthServer;
+    getUiStatus(): unknown;
+}