@songsid/agend 2.3.0-beta.2 → 2.3.0-beta.20

package/dist/outbound-handlers.js

@@ -15,7 +15,7 @@ import { CHAT_PROFILE_LOGIN_BACKENDS, credentialProfileLogin, credentialSwitchCa
 import { kiroEngineCandidates, kiroEngineStatus } from "./kiro-engine-status.js";
 import { noPlaceMarkers, placeRef, renderPlaceRefs, stripPlaceRefs, webRoute } from "./topic-link.js";
 import { formatCrossInstanceInboundMessage, MAX_ASSEMBLED_CROSS_INSTANCE_MESSAGE_BYTES, } from "./cross-instance-envelope.js";
-import { BroadcastArgs, CreateInstanceArgs, CreateTeamArgs, DelegateTaskArgs, DeleteInstanceArgs, DeleteTeamArgs, DeployTemplateArgs, DescribeInstanceArgs, ListDeploymentsArgs, ListInstancesArgs, ListTeamsArgs, ReplaceInstanceArgs, ReportResultArgs, DeliveryStatusArgs, RequestInformationArgs, RestartInstanceArgs, SendToInstanceArgs, PauseInstanceArgs, WakeInstanceArgs, StopInstanceArgs, GetInstanceLogsArgs, GetEffortArgs, ClosePollArgs, KiroEngineStatusArgs, GetUsageArgs, GetCacheReportArgs, ListModelsArgs, GetFleetConfigArgs, UpdateInstanceConfigArgs, UpdateFleetDefaultsArgs, StartInstanceArgs, TeardownDeploymentArgs, UpdateTeamArgs, validateArgs, } from "./outbound-schemas.js";
+import { BroadcastArgs, CreateInstanceArgs, CreateTeamArgs, DelegateTaskArgs, DeleteInstanceArgs, DeleteTeamArgs, DeployTemplateArgs, DescribeInstanceArgs, ListDeploymentsArgs, ListInstancesArgs, ListTeamsArgs, ReplaceInstanceArgs, ReportResultArgs, DeliveryStatusArgs, RequestInformationArgs, RestartInstanceArgs, SendToInstanceArgs, PauseInstanceArgs, WakeInstanceArgs, StopInstanceArgs, GetInstanceLogsArgs, GetEffortArgs, ClosePollArgs, KiroEngineStatusArgs, GetUsageArgs, GetCacheReportArgs, GetUsageReportArgs, GetWebSettingsArgs, SetWebSettingsArgs, ListModelsArgs, GetFleetConfigArgs, UpdateInstanceConfigArgs, UpdateFleetDefaultsArgs, StartInstanceArgs, TeardownDeploymentArgs, UpdateTeamArgs, validateArgs, } from "./outbound-schemas.js";
 const HOME_DIR = homedir();
 function formatByteSize(bytes) {
     if (bytes < 1024)
@@ -413,6 +413,10 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
     ctx.logger.info(`✉ ${senderLabel} → ${targetName}: ${(message ?? "").slice(0, 100)} [msg=${ipcMeta.message_id} sha=${deliveryContentDigest(message ?? "").slice(0, 12)}]`);
     const taskSummary = ipcMeta.task_summary || (message ?? "").slice(0, 200);
     ctx.eventLog?.logActivity("message", senderLabel, taskSummary, targetName, ipcMeta.request_kind);
+    // #2293: indexed for the dashboard's search as the outbox keeps it (a retried call the outbox admitted before: not again).
+    if (!durableReceipt?.duplicate)
+        ctx.indexCrossInstance?.({ messageId: ipcMeta.message_id, from: senderLabel, to: targetName, kind: ipcMeta.request_kind,
+            correlationId: ipcMeta.correlation_id, taskSummary: ipcMeta.task_summary, content: message ?? "", ts: ipcMeta.ts });
     ctx.queueMirrorMessage?.(`${displayLabel(senderLabel)} → ${displayLabel(targetName)}: ${truncatePreview(message ?? "", 500)}`);
     const targetDaemon = ctx.lifecycle.daemons.get(targetInstanceName);
     const targetStateWarning = targetDaemon?.isErrorState
@@ -522,7 +526,8 @@ const listInstances = (ctx, rawArgs, respond, meta) => {
     }
     if (filterName) {
         const lowerName = filterName.toLowerCase();
-        allInstances = allInstances.filter(i => i.name.toLowerCase().includes(lowerName));
+        allInstances = allInstances.filter(i => i.name.toLowerCase().includes(lowerName) ||
+            (i.display_name?.toLowerCase().includes(lowerName) ?? false));
     }
     if (filterBackend) {
         allInstances = allInstances.filter(i => i.backend === filterBackend);
@@ -552,6 +557,7 @@ const listInstances = (ctx, rawArgs, respond, meta) => {
     const compactInstances = allInstances.map(i => ({
         name: i.name,
         status: i.status,
+        ...(i.display_name ? { display_name: i.display_name } : {}),
         backend: i.backend,
         model: i.model,
         kind: i.kind,
@@ -603,6 +609,7 @@ const describeInstance = (ctx, rawArgs, respond) => {
             name: targetName,
             type: "instance",
             kind: "fleet-topic",
+            display_name: config.display_name ?? null,
             description: config.description ?? null,
             tags: config.tags ?? [],
             working_directory: config.working_directory,
@@ -789,11 +796,37 @@ const stopInstance = async (ctx, rawArgs, respond) => {
 };
 const getFleetStatus = (ctx, rawArgs, respond) => {
     const instances = ctx.fleetConfig?.instances ?? {};
-    const names = Object.keys(instances);
-    const running = names.filter(n => ctx.lifecycle.daemons.has(n) && !ctx.lifecycle.isPaused(n)).length;
-    const paused = names.filter(n => ctx.lifecycle.isPaused(n)).length;
-    const stopped = names.length - running - paused;
-    respond({ total: names.length, running, paused, stopped });
+    const fleetNames = Object.keys(instances);
+    const fleetRunning = fleetNames.filter(n => ctx.lifecycle.daemons.has(n) && !ctx.lifecycle.isPaused(n)).length;
+    const fleetPaused = fleetNames.filter(n => ctx.lifecycle.isPaused(n)).length;
+    const fleetStopped = fleetNames.length - fleetRunning - fleetPaused;
+    // Classic channels — same status source as list_instances and agend ls.
+    // Dedup: skip names already in the fleet (same-name fleet instance wins),
+    // AND skip classic names already seen (two channels can share an instanceName).
+    const fleetNameSet = new Set(fleetNames);
+    const seenClassic = new Set();
+    const classicAll = [];
+    if (ctx.classicChannels) {
+        for (const ch of ctx.classicChannels.getAll()) {
+            if (fleetNameSet.has(ch.instanceName))
+                continue;
+            if (seenClassic.has(ch.instanceName))
+                continue;
+            seenClassic.add(ch.instanceName);
+            classicAll.push(ch.instanceName);
+        }
+    }
+    const classicRunning = classicAll.filter(n => ctx.lifecycle.daemons.has(n) && !ctx.lifecycle.isPaused(n)).length;
+    const classicPaused = classicAll.filter(n => ctx.lifecycle.isPaused(n)).length;
+    const classicStopped = classicAll.length - classicRunning - classicPaused;
+    respond({
+        total: fleetNames.length + classicAll.length,
+        running: fleetRunning + classicRunning,
+        paused: fleetPaused + classicPaused,
+        stopped: fleetStopped + classicStopped,
+        fleet: { total: fleetNames.length, running: fleetRunning, paused: fleetPaused, stopped: fleetStopped },
+        classic: { total: classicAll.length, running: classicRunning, paused: classicPaused, stopped: classicStopped },
+    });
 };
 const kiroEngineStatusHandler = (ctx, rawArgs, respond) => {
     const v = validateArgs(KiroEngineStatusArgs, rawArgs, "kiro_engine_status");
@@ -871,6 +904,43 @@ const getUsage = async (ctx, rawArgs, respond) => {
         respond(null, `Usage fetch failed: ${err.message}`);
     }
 };
+/**
+ * #2056: Settings → Web appearance for the user — get_web_settings / set_web_settings, through the page's own stores and
+ * checks (web-settings-tools.ts). Who may call them is the tool profile (General, coordinator, full), at every sink.
+ */
+const getWebSettings = async (ctx, rawArgs, respond) => {
+    const v = validateArgs(GetWebSettingsArgs, rawArgs, "get_web_settings");
+    if (!v.ok) {
+        respond(null, v.error);
+        return;
+    }
+    if (!ctx.webSettings) {
+        respond(null, "get_web_settings is unavailable on this fleet");
+        return;
+    }
+    const r = ctx.webSettings.read(v.data.person);
+    if (r.ok)
+        respond(r);
+    else
+        respond(null, `get_web_settings: ${r.error}${r.detail ? ` — ${r.detail}` : ""}`);
+};
+const setWebSettings = async (ctx, rawArgs, respond) => {
+    const v = validateArgs(SetWebSettingsArgs, rawArgs, "set_web_settings");
+    if (!v.ok) {
+        respond(null, v.error);
+        return;
+    }
+    if (!ctx.webSettings) {
+        respond(null, "set_web_settings is unavailable on this fleet");
+        return;
+    }
+    try {
+        respond(ctx.webSettings.change(v.data.person, v.data.change));
+    }
+    catch (err) {
+        respond(null, `set_web_settings failed: ${err.message}`);
+    }
+};
 /**
  * #2001: the prompt-cache report for an agent. From the last scan (cacheReportPublished: in-memory ledgers, reused
  * for a minute) — no transcript read and no process on the fleet loop. Who sees what: cacheReportScope.
@@ -904,6 +974,49 @@ const getCacheReport = async (ctx, rawArgs, respond, meta) => {
         respond(null, `get_cache_report failed: ${err.message}`);
     }
 };
+/**
+ * #2122: the usage report for an agent — the dashboard's Fleet → Usage, from the last scan (no transcript read). Who
+ * sees what: cacheReportScope (its own row, or the fleet). Every amount carries `basis`: the API-equivalent at list
+ * price, not money spent.
+ */
+const getUsageReport = async (ctx, rawArgs, respond, meta) => {
+    const v = validateArgs(GetUsageReportArgs, rawArgs, "get_usage_report");
+    if (!v.ok) {
+        respond(null, v.error);
+        return;
+    }
+    const caller = meta?.instanceName;
+    if (!caller) {
+        respond(null, "get_usage_report: the calling instance is unknown");
+        return;
+    }
+    if (!ctx.usageReport) {
+        respond(null, "get_usage_report is unavailable on this fleet");
+        return;
+    }
+    const { resolveToolSet, cacheReportScope } = await import("./tool-permissions.js");
+    const { usageRange, usageGroup } = await import("./usage-report.js");
+    const scope = cacheReportScope(resolveToolSet(ctx.fleetConfig?.instances[caller], caller));
+    if (scope === "own" && v.data.instance !== undefined && v.data.instance !== caller) {
+        respond(null, "get_usage_report: an instance reads only its own row");
+        return;
+    }
+    const only = scope === "own" ? caller : v.data.instance;
+    try {
+        const r = await ctx.usageReport({ range: usageRange(v.data.range, v.data.from, v.data.to), group: scope === "own" ? "instance" : usageGroup(v.data.group), ...(only ? { only } : {}) });
+        const top = v.data.top ?? 10;
+        respond({
+            basis: r.basis, range: r.range, zone: r.zone, granularity: r.granularity, group: r.group,
+            rows: r.rows.slice(0, top).map(row => ({ ...row, basis: r.basis })),
+            more: Math.max(0, r.rows.length - top),
+            totals: { ...r.totals, basis: r.basis },
+            notMeasured: r.notMeasured, shared: r.shared, scanning: r.scanning,
+        });
+    }
+    catch (err) {
+        respond(null, `get_usage_report failed: ${err.message}`);
+    }
+};
 /**
  * Enumerate a backend's models. Read-only and best-effort by design: the
  * catalog is an aid for picking a name, and AgEnD passes model strings through
@@ -1471,7 +1584,10 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     const senderLabel = meta.senderSessionName ?? meta.instanceName;
     const operationId = ctx.admitDurableDelivery ? meta.operationId ?? randomUUID() : meta.operationId;
     const senderDisplay = ctx.fleetConfig?.instances[senderLabel]?.display_name;
-    const makeBroadcastMeta = (correlationId, messageId = `bcast-${Date.now()}`) => {
+    // One message id for this broadcast — every target's row shares it (delivery_status by message_id finds them all) —
+    // and no other broadcast's: a millisecond alone is not unique (#2295 review; the search index keys on it).
+    const broadcastMessageId = `bcast-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const makeBroadcastMeta = (correlationId, messageId = broadcastMessageId) => {
         const ipcMeta = {
             chat_id: "", message_id: messageId, user: `instance:${senderLabel}`,
             user_id: `instance:${senderLabel}`, ts: new Date().toISOString(), thread_id: "",
@@ -1490,7 +1606,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     // Validate once before dispatching any target. The placeholders are the
     // longest values generated below, so every real per-target envelope fits if
     // this one does. Keeping this outside the loop prevents partial broadcasts.
-    if (rejectOversizedCrossInstanceEnvelope(message, makeBroadcastMeta("bcast-9999999999999-zzzzzz", "bcast-9999999999999"), respond, "either"))
+    if (rejectOversizedCrossInstanceEnvelope(message, makeBroadcastMeta("bcast-9999999999999-zzzzzz", "bcast-9999999999999-zzzzzz"), respond, "either"))
         return;
     // Resolve target list: team, explicit targets, tag filter, or all running
     let targetNames;
@@ -1520,6 +1636,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     // target's idle gate blocked for as long as the BUSIEST recipient. Connectivity
     // is decided synchronously (that's the real failure), delivery runs in background.
     const sentTo = [];
+    const sentMeta = new Map();
     const failed = [];
     for (const targetName of targetNames) {
         const hostInstance = ctx.instanceIpcClients.has(targetName) ? targetName : ctx.sessionRegistry.get(targetName);
@@ -1530,9 +1647,10 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
         const correlationId = `bcast-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const ipcMeta = makeBroadcastMeta(correlationId);
         const payload = { type: "fleet_inbound", targetSession: targetName, content: message, meta: ipcMeta };
+        let duplicate = false;
         if (ctx.admitDurableDelivery) {
             try {
-                ctx.admitDurableDelivery({
+                duplicate = ctx.admitDurableDelivery({
                     operationId: operationId,
                     sourceDaemonBootId: meta.sourceDaemonBootId ?? ctx.getDaemonBootId?.(meta.instanceName),
                     sourceInstance: meta.instanceName,
@@ -1541,7 +1659,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
                     kind: "broadcast",
                     correlationId,
                     payload,
-                });
+                })?.duplicate === true;
             }
             catch (err) {
                 ctx.logger.error({ err, target: targetName, source: meta.instanceName }, "Durable broadcast admission failed closed");
@@ -1554,11 +1672,18 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
             void deliverCrossInstanceWithRetry(ctx, hostInstance, targetName, senderLabel, correlationId, payload);
         }
         sentTo.push(targetName);
+        // #2293: indexed as the outbox keeps it — a retried call the outbox admitted before keeps the first call's row.
+        if (!duplicate)
+            sentMeta.set(targetName, ipcMeta);
     }
     ctx.logger.info(`📢 ${senderLabel} broadcast to ${sentTo.length} instances: ${(message).slice(0, 80)}`);
     const summary = task_summary || message.slice(0, 200);
     for (const target of sentTo) {
         ctx.eventLog?.logActivity("message", senderLabel, summary, target);
+        const sent = sentMeta.get(target);
+        if (sent)
+            ctx.indexCrossInstance?.({ messageId: sent.message_id, from: senderLabel, to: target, kind: sent.request_kind ?? "broadcast",
+                correlationId: sent.correlation_id, taskSummary: task_summary, content: message, ts: sent.ts });
     }
     // Mirror Topic is user-facing: display labels, never long ids (#1301),
     // unique across the fleet (#1305 P2-1).
@@ -2027,6 +2152,9 @@ export const outboundHandlers = new Map([
     ["kiro_engine_status", kiroEngineStatusHandler],
     ["get_usage", getUsage],
     ["get_cache_report", getCacheReport],
+    ["get_usage_report", getUsageReport],
+    ["get_web_settings", getWebSettings],
+    ["set_web_settings", setWebSettings],
     ["list_models", listModels],
     ["get_instance_logs", getInstanceLogs],
     ["get_fleet_config", getFleetConfig],