@songsid/agend 2.2.0-beta.10 → 2.2.0-beta.12

package/dist/fleet-manager.js

@@ -20,7 +20,7 @@ import { withinBudget } from "./monotonic-budget.js";
 import { measureSyncWork } from "./sync-work-attribution.js";
 import { RuntimeCpuProfiler, ProfileBusyError, profileDuration } from "./runtime-cpu-profile.js";
 import { ProfileControlServer } from "./profile-control.js";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, constants as fsConstants } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, constants as fsConstants, closeSync } from "node:fs";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
@@ -141,8 +141,10 @@ import { WebChatHistory, WEB_CHAT_TEXT_MAX, isWebMessageId, newWebMessageId } fr
 import { WebChatDiskStore } from "./web-chat-store.js";
 import { SeenUsers, resolveMentions } from "./web-mentions.js";
 import { WebPrefsStore } from "./web-prefs.js";
+import { WEB_NAME_FALLBACK, safeWebName, validateWebName, webNameInUse, webPersonKey } from "./web-profile.js";
 import { ReplyButtonStore, parseReplyButtons, replyButtonClickText, replyButtonsFallbackText, REPLY_BUTTON_PREFIX } from "./reply-buttons.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
+import { parsePoll } from "./reply-polls.js";
 import { publicAttachment, sweepOrphanedUploads, WebFileLedger } from "./web-upload.js";
 import { REPLY_FILES_MAX_BYTES, snapshotReplyFile, sweepReplySnapshots, webFilesDir } from "./web-reply-files.js";
 import { handleViewRequest, isViewPath, profileIdentities, resolveInstanceIdentity } from "./view-api.js";
@@ -162,7 +164,7 @@ import { canonicalCommand, commandSpec, decideCommand, ruleFor } from "./command
 import { runVisibilityCommand } from "./cross-instance-notice.js";
 import { installedChannel, isPrereleaseVersion, updateNoticeKey } from "./update-check.js";
 import { resolveInstalledAgend } from "./update-dispatch.js";
-import { resolveUpdateLaunch, watchUpdateLaunch } from "./update-launch.js";
+import { resolveUpdateLaunch, openUpdateLog, updateLogPath, watchUpdateLaunch } from "./update-launch.js";
 import { admitProfileLogin, LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS } from "./login-controller.js";
 import { runBeforeDeadline } from "./deadline.js";
 import { LoginWindowLock } from "./login-window-lock.js";
@@ -380,6 +382,7 @@ const WEB_MIRRORED_PROMPT_PREFIXES = new Set([
 const WEB_ONLY_REPLY_SINK = {
     type: "web",
     supportsReplyButtons: true, // #1266: the web chat shows a reply's buttons itself
+    supportsPolls: true, // #1823: …and a poll (its pages are told; there is nothing to edit)
     sendText: async () => ({ chatId: "web", messageId: newWebMessageId() }),
     sendFile: async () => ({ chatId: "web", messageId: newWebMessageId() }),
 };
@@ -807,6 +810,78 @@ export class FleetManager {
     seenUsers = new SeenUsers();
     webPrefsStore;
     /** #1665: the web preferences kept on the host (<home>/web-prefs.json), read on first use. */
+    /**
+     * #1827: a web person as agents and chats see them. Signed in as an account (a sign-in code DMed to it): that
+     * account's user id — still `via web`, and only for recognition — and the name they chose, else their account's name
+     * at sign-in (made safe). Otherwise (an `agend web` session): "web-user", as before, under a name the operator may set.
+     * Names are checked again now: one an instance or bot has taken since reads as the next choice down.
+     */
+    webPerson(owner) {
+        const key = webPersonKey(owner);
+        let profile = null;
+        try {
+            profile = this.webPrefs.profile(key);
+        }
+        catch (err) {
+            this.logger.warn({ err: err.message }, "Web profile unavailable");
+        }
+        const reserved = (n) => this.webNameReserved(n);
+        const own = profile?.name !== undefined ? webNameInUse(profile.name, reserved) : WEB_NAME_FALLBACK;
+        const chosen = own !== WEB_NAME_FALLBACK;
+        const platformName = owner ? safeWebName(profile?.platformName, reserved) : undefined;
+        return {
+            key, bound: !!owner,
+            userId: owner ? owner.userId : WEB_NAME_FALLBACK,
+            // A poll ballot is the account's — the same key its votes on the platform have — or the operator's.
+            voterKey: owner ? `${owner.adapterId}:${owner.userId}` : "web:operator",
+            name: chosen ? own : platformName ?? WEB_NAME_FALLBACK,
+            set: chosen,
+            ...(platformName !== undefined ? { platformName } : {}),
+        };
+    }
+    /** #1827: set (null: clear — back to their account's name) a web person's own name; validated in full. */
+    setWebPersonName(owner, raw) {
+        let name = null;
+        if (raw !== null) {
+            const v = validateWebName(raw, (n) => this.webNameReserved(n));
+            if (!v.ok)
+                return { ok: false, status: 400, error: v.error };
+            name = v.name;
+        }
+        const w = this.webPrefs.setProfileName(webPersonKey(owner), name);
+        return w.ok ? { ok: true, person: this.webPerson(owner) } : { ok: false, status: w.status, error: w.error };
+    }
+    /** #1827 (auth-api): a sign-in as this account — its display name then is the web name it starts with. */
+    noteWebSignIn(account) {
+        if (account.username)
+            this.webPrefs.setPlatformName(webPersonKey(account), account.username);
+    }
+    /**
+     * #1827: a name that belongs to something here — an instance (or ClassicBot room), its display name, a bot. On the web
+     * send path: it never throws (a lookup that fails reserves nothing; the name was checked in full when it was set).
+     */
+    webNameReserved(lowered) {
+        try {
+            return this.webNameTaken(lowered);
+        }
+        catch {
+            return false;
+        }
+    }
+    webNameTaken(lowered) {
+        const low = (s) => (typeof s === "string" ? s.normalize("NFC").toLocaleLowerCase("en-US") : "");
+        for (const [name, cfg] of Object.entries(this.fleetConfig?.instances ?? {})) {
+            if (low(name) === lowered || low(cfg.display_name) === lowered)
+                return true;
+        }
+        for (const ch of this.classicChannels?.getAll() ?? [])
+            if (low(ch.instanceName) === lowered || low(ch.displayName) === lowered)
+                return true;
+        for (const w of this.worlds.values())
+            if (w.botUsername && low(w.botUsername) === lowered)
+                return true;
+        return false;
+    }
     get webPrefs() {
         // #1664: a favorite must be an instance of this fleet now — fleet.yaml's (own keys) or a ClassicBot room's.
         return (this.webPrefsStore ??= new WebPrefsStore(this.dataDir, {
@@ -1155,6 +1230,8 @@ export class FleetManager {
             mayClick: (set, userId) => this.mayAnswerReplyButtons(set.instance, set.adapterId, userId),
             deliver: (set, button, by) => this.deliverReplyButtonChoice(set, button, by),
             publish: (instance, view) => this.emitSseEvent("reply_buttons", { instance, buttons: view }),
+            admitResults: (set, key, text) => this.admitPollResults(set, key, text),
+            monotonic: () => performance.now(),
             logger: this.logger,
             setTimer: (fn, ms) => { const h = setTimeout(fn, ms); h.unref?.(); return h; },
             clearTimer: (h) => clearTimeout(h),
@@ -1163,6 +1240,21 @@ export class FleetManager {
         return this.replyButtonsCtl;
     }
     replyButtonsStore = null;
+    /**
+     * #1823: a closed poll's results go to its instance through the delivery outbox, as a system notice keyed by the
+     * poll: durable (held until the instance can take it) and admitted once, however often this is asked. Addressed to
+     * the poll's chat, so the instance's answer (the right option, the scores) goes there.
+     */
+    admitPollResults(set, key, text) {
+        this.ensureDeliveryOutbox();
+        const outbox = this.deliveryOutbox;
+        if (!outbox)
+            return false;
+        outbox.admitSystemNotice(set.instance, key, text, new Date(), {
+            chatId: set.chatId, threadId: set.threadId || undefined, adapterId: set.adapterId === "web" ? undefined : set.adapterId,
+        });
+        return true;
+    }
     /**
      * #1266: who may answer a reply's buttons on a platform — whoever may message that instance there: in a ClassicBot
      * room anyone there (as a typed message), elsewhere someone the sending connection lets speak (#754/#1148), never a
@@ -2238,10 +2330,15 @@ export class FleetManager {
             this.failUpdateProgress(t("not_authorized"));
             return;
         }
+        const logPath = updateLogPath(this.dataDir);
+        const ts = new Date().toISOString();
+        const logFd = openUpdateLog(logPath, `--- /update ${ts} ---`);
         const child = spawn(launch.command, launch.args, {
-            detached: true, stdio: "ignore", env: withOrigin(origin),
+            detached: true, stdio: ["ignore", logFd ? logFd.fd : "ignore", logFd ? logFd.fd : "ignore"], env: withOrigin(origin),
         });
-        watchUpdateLaunch(child, message => this.failUpdateProgress(message));
+        if (logFd)
+            closeSync(logFd.fd); // parent closes its copy; the child's fd stays open
+        watchUpdateLaunch(child, message => this.failUpdateProgress(message), logFd ? logPath : undefined, logFd?.offset, installed.agend);
         child.unref();
     }
     async handleProfileSlash(data, adapterId) {
@@ -3123,7 +3220,8 @@ export class FleetManager {
      * or a rebound adapter is never posted through a stale route. A copy
      * already in flight may still land late — the contract permits that.
      */
-    async sendClassicWebEcho(instance, text) {
+    /** `sender` (#1827): the web person's name, as the room log records them ("web-user" when none). */
+    async sendClassicWebEcho(instance, text, sender = WEB_NAME_FALLBACK) {
         const guard = this.webChannelEchoGuards.get(instance);
         const handled = new Set();
         let posted = 0;
@@ -3154,7 +3252,7 @@ export class FleetManager {
                 if (!adapter?.sendText)
                     continue;
                 await adapter.sendText(entry.channelId, text, { format: "text", allowedMentions: { parse: [] } });
-                ClassicChannelManager.logMessage(instance, "web-user", text, new Date());
+                ClassicChannelManager.logMessage(instance, sender, text, new Date());
                 posted++;
             }
             catch (err) {
@@ -3713,7 +3811,7 @@ export class FleetManager {
                 await data.respond(result.durable ? t("dashboard.revoked", result.count) : t("dashboard.revoked_not_durable", result.count));
             }
             else {
-                const owner = this.dashboardOwner(data.userId, adapterId, data.channelId);
+                const owner = this.dashboardOwner(data.userId, adapterId, data.channelId, undefined, data.username);
                 if (!owner) {
                     await this.sendLocalDashboard(data, adapterId);
                     return;
@@ -5035,7 +5133,7 @@ export class FleetManager {
             && cfg.topic_id?.toString() === owner.threadId);
     }
     /** Exact owning General. No primary-adapter or name fallback participates in authorization. */
-    dashboardOwner(userId, adapterId, address, threadId) {
+    dashboardOwner(userId, adapterId, address, threadId, username) {
         const world = this.worlds.get(adapterId);
         if (!world || !this.hasFleetAdmins(adapterId) || !this.isFleetAdmin(userId, adapterId))
             return null;
@@ -5050,7 +5148,7 @@ export class FleetManager {
             const matched = dc ? topic === address || (group === address && topic === threadId)
                 : group === address && ((topic === "1" && (threadId === undefined || threadId === "1")) || topic === threadId);
             if (group && matched)
-                return { userId, adapterId, chatId: group, threadId: topic, binding: world.adapter };
+                return { userId, adapterId, chatId: group, threadId: topic, binding: world.adapter, ...(username ? { username } : {}) };
         }
         return null;
     }
@@ -5059,7 +5157,7 @@ export class FleetManager {
      * — this bot's configured group and its one General topic. No address to match in a DM, so it must be unambiguous:
      * no General, or more than one on this bot and group, and there is no owner (nothing is guessed).
      */
-    dmDashboardOwner(userId, adapterId) {
+    dmDashboardOwner(userId, adapterId, username) {
         const world = this.worlds.get(adapterId);
         if (!world || !this.hasFleetAdmins(adapterId) || !this.isFleetAdmin(userId, adapterId))
             return null;
@@ -5073,7 +5171,7 @@ export class FleetManager {
             .map(([, cfg]) => cfg.topic_id.toString());
         if (topics.length !== 1)
             return null;
-        const owner = { userId, adapterId, chatId: group, threadId: topics[0], binding: world.adapter };
+        const owner = { userId, adapterId, chatId: group, threadId: topics[0], binding: world.adapter, ...(username ? { username } : {}) };
         return this.publicOwnerCurrent(owner) ? owner : null;
     }
     /**
@@ -5100,7 +5198,7 @@ export class FleetManager {
     async startWebInDm(msg, adapter) {
         if (!adapter)
             return;
-        const owner = msg.chatId === msg.userId ? this.dmDashboardOwner(msg.userId, msg.adapterId ?? "") : null;
+        const owner = msg.chatId === msg.userId ? this.dmDashboardOwner(msg.userId, msg.adapterId ?? "", msg.username) : null;
         if (!owner) {
             await adapter.sendText(msg.chatId, t("dashboard.start_web_ack"));
             return;
@@ -5153,7 +5251,7 @@ export class FleetManager {
     /** Telegram's typed command enters through the same strict owner and nonce path as Discord. */
     async dashboardMenu(msg) {
         const id = msg.adapterId;
-        const owner = id ? this.dashboardOwner(msg.userId, id, msg.chatId, msg.threadId) : null;
+        const owner = id ? this.dashboardOwner(msg.userId, id, msg.chatId, msg.threadId, msg.username) : null;
         if (!owner) {
             const adapter = id ? this.adapters.get(id) : undefined;
             await adapter?.sendText(msg.chatId, t("dashboard.public_general"), { threadId: msg.threadId });
@@ -5186,7 +5284,9 @@ export class FleetManager {
             return;
         }
         this.initializeWebSessions();
-        const login = this.webLoginCodes.issue({ epoch: tokenEpoch(token) });
+        // #1827: the code goes privately to this account (a DM, or else this slash command's ephemeral answer): whoever
+        // redeems it is recognised as that account. Recognition only — no owner (this is not an owning General's code).
+        const login = this.webLoginCodes.issue({ epoch: tokenEpoch(token), recipient: { adapterId, userId: data.userId, ...(data.username ? { username: data.username } : {}) } });
         const current = () => !this.shuttingDown && this.adapters.get(adapterId) === adapter
             && this.webToken === token && this.hasFleetAdmins(adapterId) && this.isFleetAdmin(data.userId, adapterId);
         const privateText = `${text}\n${t("dashboard.code", login.display, Math.round(LOGIN_CODE_TTL_MS / 60_000))}`;
@@ -6412,6 +6512,7 @@ export class FleetManager {
         // Health HTTP endpoint
         this.startHealthServer(fleet.health_port ?? 19280);
         // #1266: buttons that ended while AgEnD was down (expired, or chosen before a restart) are shown as ended now.
+        // #1823: and polls: a deadline that passed meanwhile closes now (results once); an open one's countdown is redrawn.
         void this.replyButtons()?.sweep().catch(err => this.logger.warn({ err }, "Reply-button sweep failed"));
         // Daily update check — first check after 1 hour, then every 24 hours
         this.updateCheckTimer = setTimeout(() => {
@@ -8524,6 +8625,17 @@ export class FleetManager {
                 respond(null, `reply: ${parsedButtons.error}`);
                 return;
             }
+            // #1823: a poll is checked with its buttons. Where it cannot be shown it is refused, never sent as text: text
+            // options would never come back as results.
+            const parsedPoll = parsePoll(args.poll, parsedButtons && "buttons" in parsedButtons ? parsedButtons.buttons : null, args.text);
+            if (parsedPoll && "error" in parsedPoll) {
+                respond(null, `reply: ${parsedPoll.error}`);
+                return;
+            }
+            if (parsedPoll && (!outAdapter.supportsPolls || !this.replyButtons())) {
+                respond(null, `reply: a poll cannot be shown here${outAdapter.supportsPolls ? " (reply buttons are unavailable until AgEnD restarts)" : " — polls work in Discord and Telegram chats and the web chat"}; send the question without poll`);
+                return;
+            }
             // Stickers (#1226) are checked before anything is sent: a refused one is the reply's error, not a gap.
             const stickerProblem = await this.replyStickerProblem(outAdapter, args, threadId, contextAdapterId ?? this.getInstanceAdapterId(senderInstanceName ?? instanceName));
             if (stickerProblem) {
@@ -8543,7 +8655,7 @@ export class FleetManager {
                 const buttons = outAdapter.supportsReplyButtons ? this.replyButtons() : null;
                 if (buttons) {
                     const outId = outAdapter === WEB_ONLY_REPLY_SINK ? "web" : outAdapter.id ?? contextAdapterId ?? "";
-                    replySet = buttons.prepare({ instance: instanceName, adapterId: outId, chatId: String(args.chat_id ?? ""), threadId }, parsedButtons.buttons);
+                    replySet = buttons.prepare({ instance: instanceName, adapterId: outId, chatId: String(args.chat_id ?? ""), threadId }, parsedButtons.buttons, parsedPoll && "poll" in parsedPoll ? parsedPoll.poll : null);
                 }
                 else {
                     args.text = `${String(args.text)}\n\n${replyButtonsFallbackText(parsedButtons.buttons)}`;
@@ -8563,6 +8675,9 @@ export class FleetManager {
                         this.replyButtonsCtl?.discard(replySet.id);
                     }
                 }
+                // #1823: the agent learns its poll's id (the results name it).
+                if (replySet?.poll && !error && result && typeof result === "object")
+                    result = { ...result, poll_id: replySet.id };
                 ticket.complete(result, error);
                 // Return the platform outcome first. Bookkeeping below must never turn
                 // a confirmed Discord/Telegram POST into a tool error if a secondary
@@ -8590,7 +8705,7 @@ export class FleetManager {
                     });
                 }
             };
-            if (routeToolCall(outAdapter, tool, args, threadId, respondAndRecord, replySet ? { replyButtons: replySet.callbacks } : {})) {
+            if (routeToolCall(outAdapter, tool, args, threadId, respondAndRecord, replySet ? { replyButtons: replySet.callbacks, ...(replySet.poll ? { replyPoll: replySet.poll } : {}) } : {})) {
                 return;
             }
             if (replySet)
@@ -12120,10 +12235,18 @@ export class FleetManager {
      * The caller has passed the /ui gate (session, same origin, CSRF). Here: the prompt must be one offered
      * on the dashboard, about the instance the page named, and the action one of its own buttons.
      */
-    /** #1266: a click on a reply's button in the web chat (the /ui gate is passed: a session, or the public link). */
-    clickWebReplyButton(instance, id, index) {
+    /** #1823: close_poll — `instance` closes one of its own polls before the deadline. */
+    closePollEarly(instance, id) {
+        const buttons = this.replyButtons();
+        return buttons ? buttons.closeEarly(instance, id) : Promise.resolve({ ok: false, error: "polls are unavailable until AgEnD restarts" });
+    }
+    /**
+     * #1266: a click on a reply's button in the web chat (the /ui gate is passed: a session, or the public link). On a
+     * poll (#1823) it is `voter`'s vote: the page's session.
+     */
+    clickWebReplyButton(instance, id, index, voter) {
         const buttons = this.replyButtons();
-        return buttons ? buttons.clickWeb(instance, id, index) : Promise.resolve({ status: 409, error: t("reply_buttons.closed") });
+        return buttons ? buttons.clickWeb(instance, id, index, voter) : Promise.resolve({ status: 409, error: t("reply_buttons.closed") });
     }
     async clickWebPrompt(instance, nonce, action) {
         if (!/^[0-9a-f]{32}$/.test(nonce) || !/^[a-z][a-z-]{0,23}$/.test(action))
@@ -12485,7 +12608,9 @@ export class FleetManager {
         const webMeta = (instance) => {
             const topicId = this.fleetConfig?.instances[instance]?.topic_id;
             return {
-                chatId: this.getGroupIdForInstance(instance) || "", messageId: newWebMessageId(), username: "web-user", userId: "web-user",
+                // #1827: a /steer or /btw reaches the agent as the web person who wrote it.
+                chatId: this.getGroupIdForInstance(instance) || "", messageId: newWebMessageId(),
+                username: opts.person?.name ?? WEB_NAME_FALLBACK, userId: opts.person?.userId ?? WEB_NAME_FALLBACK,
                 threadId: topicId != null ? String(topicId) : undefined, adapterId: this.getAdapterForInstance(instance)?.id ?? "", source: "web", humanOrigin: webHumanOrigin(true),
             };
         };
@@ -16195,7 +16320,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** How this instance's backend applies an effort change. */
     effortStrategyFor(instanceName) {
         try {
-            const { strategy, levels } = readEffortMetadata(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            const { strategy, levels } = this.instanceEffortMetadata(instanceName);
             return strategy !== "unsupported" && levels.length > 0 ? strategy : "unsupported";
         }
         catch {
@@ -16205,13 +16330,23 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** Effort levels this instance's backend actually accepts (empty = unsupported). */
     effortLevelsFor(instanceName) {
         try {
-            const { strategy, levels } = readEffortMetadata(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            const { strategy, levels } = this.instanceEffortMetadata(instanceName);
             return strategy === "unsupported" ? [] : levels;
         }
         catch {
             return [];
         }
     }
+    /** The instance's backend's effort metadata; agy's levels are its model's (#1825), the one the instance runs. */
+    instanceEffortMetadata(instanceName) {
+        const backend = this.backendNameForInstance(instanceName);
+        let model = null;
+        if (backend === "antigravity") {
+            const resolved = this.resolveInstanceModel(instanceName);
+            model = resolved.source === "unresolved" ? null : resolved.model;
+        }
+        return readEffortMetadata(backend, this.getInstanceDir(instanceName), model);
+    }
     /** Configured effort for an instance: per-instance, else fleet default, else none. */
     resolveInstanceEffort(instanceName) {
         const own = this.fleetConfig?.instances[instanceName]?.effort;