@jmfederico/pi-web 1.202610.2 → 1.202610.3

package/dist/server/sessions/piSessionService.js

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 import { join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
+import { QueueCompatibilityGuard, mirroredQueueEntries, mutableQueueAgent, mutableTextMirror, parseQueueMessageMutation, queuedMessageAttachmentCounts, queuedMessageAttachmentCount, snapshotAgentQueues } from "./queuedMessageMutation.js";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEventBus, createEditToolDefinition, defineTool, hasTrustRequiringProjectResources, ProjectTrustStore, readStoredCredential, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { projectBrowserMessage } from "../browserMessageProjection.js";
 import { isSessionMediaId } from "../../shared/sessionMedia.js";
@@ -600,6 +601,9 @@ export class PiSessionService {
          * one (not for standalone commands or compaction); completion disarms it.
          */
         this.subsessionNotifyArmed = new Map();
+        this.queueCompatibility = new QueueCompatibilityGuard((session, err) => {
+            this.logger.info({ sessionId: session.sessionId, err }, "Disabled SDK-dependent queue controls after an incompatible queue interface");
+        });
         this.notificationGenerationBySession = new WeakMap();
         /** Last idle-poll transcript file resolution per runtime, throttled; entries die with their runtime. */
         this.idleSessionFileResolutions = new WeakMap();
@@ -2076,7 +2080,7 @@ export class PiSessionService {
     submitPrompt(session, text, behavior, images = [], echoUserMessage = true) {
         return this.beginPromptSubmission(session, text, behavior, images, echoUserMessage).catch(() => undefined);
     }
-    beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true) {
+    beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true, expandPromptTemplates = true) {
         this.publishActivity(session, behavior === "steer" ? "steering queued" : behavior === "followUp" ? "message queued" : "prompt accepted", "active");
         const echoes = this.pendingPromptEchoes.get(session) ?? [];
         const userCount = historyMessagesFromEntries(session.sessionManager.getBranch()).filter((message) => isRecord(message) && message["role"] === "user").length;
@@ -2089,8 +2093,8 @@ export class PiSessionService {
             this.pendingPromptEchoes.set(session, [...echoes, echo]);
             this.events.publish(session.sessionId, { type: "message.append", message: this.browserTranscriptMessage(session, echo.message) }, { id: session.sessionId, cwd: session.sessionManager.getCwd() });
         }
-        const promptOptions = buildPromptOptions(behavior, images);
-        const commandName = text.startsWith("/") ? text.slice(1).split(" ")[0] : undefined;
+        const promptOptions = expandPromptTemplates ? buildPromptOptions(behavior, images) : { ...buildPromptOptions(behavior, images), expandPromptTemplates: false };
+        const commandName = expandPromptTemplates && text.startsWith("/") ? text.slice(1).split(" ")[0] : undefined;
         const trackEarlyFailure = behavior === undefined
             && this.subsessionLinkForActiveChild(session) !== undefined
             && !session.extensionRunner.getRegisteredCommands().some((command) => command.invocationName === commandName);
@@ -2718,6 +2722,124 @@ export class PiSessionService {
         this.unregisterSubsession(session.sessionId);
         await this.forgetUnreadSessions([{ sessionId: session.sessionId, cwd: session.sessionManager.getCwd() }]);
     }
+    async mutateQueueMessage(ref, input) {
+        const mutation = parseQueueMessageMutation(input);
+        await this.assertWritable(ref);
+        const session = await this.getOrOpen(ref);
+        // Compare the entire execution-order queue after all awaits, then mutate
+        // synchronously so neither another request nor the agent loop can interleave.
+        const current = this.queuedMessages(session);
+        if (this.queueCompatibility.reason(session) !== undefined) {
+            this.publishStatus(session);
+            this.queueCompatibility.assertAvailable(session);
+        }
+        if (current.length !== mutation.expectedQueue.length || current.some((entry, index) => {
+            const expected = mutation.expectedQueue[index];
+            if (expected === undefined)
+                return true;
+            return entry.kind !== expected.kind || entry.text !== expected.text
+                || (mutation.action === "edit" && index === mutation.index && (entry.hasAttachments === true) !== (expected.hasAttachments === true));
+        }))
+            throw new Error("Queued messages changed; refresh the queue and try again");
+        if (mutation.index >= current.length)
+            throw new Error("Invalid queue index");
+        try {
+            this.queueCompatibility.run(session, () => { this.applyQueueMessageMutation(session, mutation); });
+        }
+        catch (error) {
+            this.publishStatus(session);
+            throw error;
+        }
+        this.publishStatus(session);
+        return this.statusFromSession(session);
+    }
+    applyQueueMessageMutation(session, mutation) {
+        const agent = mutableQueueAgent(session.agent);
+        const mirrors = { steer: mutableTextMirror(session.getSteeringMessages()), followUp: mutableTextMirror(session.getFollowUpMessages()) };
+        if (session.getSteeringMessages() !== mirrors.steer || session.getFollowUpMessages() !== mirrors.followUp) {
+            throw new Error("SDK queue getters no longer expose stable backing arrays");
+        }
+        const queues = snapshotAgentQueues(agent);
+        const originalQueues = { steer: [...queues.steer], followUp: [...queues.followUp] };
+        const originalMirrors = { steer: [...mirrors.steer], followUp: [...mirrors.followUp] };
+        const held = this.compactionQueuedMessages(session.sessionId).map((prompt) => ({ ...prompt }));
+        const entries = ["steer", "followUp"].flatMap((kind) => [
+            ...mirroredQueueEntries(queues[kind], mirrors[kind]).map((entry) => ({ ...entry, kind })),
+            ...held.filter((prompt) => prompt.kind === kind).map((prompt) => ({ kind, text: prompt.text, prompt })),
+        ]);
+        const selected = entries[mutation.index];
+        if (selected === undefined)
+            throw new Error("Invalid queue index");
+        const removed = mutation.action === "edit" ? entries.slice(mutation.index) : [selected];
+        const remaining = entries.filter((entry) => !removed.includes(entry));
+        for (const entry of removed) {
+            if (entry.message !== undefined) {
+                const queue = queues[entry.kind];
+                queue.splice(queue.indexOf(entry.message), 1);
+            }
+            if (entry.prompt !== undefined)
+                held.splice(held.indexOf(entry.prompt), 1);
+        }
+        if (mutation.action === "toggle") {
+            const kind = selected.kind === "steer" ? "followUp" : "steer";
+            // Destination includes held prompts: append there when necessary to keep
+            // status order and eventual execution order identical.
+            if (selected.prompt !== undefined) {
+                selected.prompt.kind = kind;
+                held.push(selected.prompt);
+                remaining.push({ ...selected, kind });
+            }
+            else if (selected.message !== undefined) {
+                if (held.some((prompt) => prompt.kind === kind)) {
+                    const prompt = { kind, text: selected.text, message: selected.message };
+                    held.push(prompt);
+                    remaining.push({ kind, text: selected.text, prompt });
+                }
+                else {
+                    queues[kind].push(selected.message);
+                    remaining.push({ ...selected, kind });
+                }
+            }
+        }
+        try {
+            agent.clearAllQueues();
+            for (const message of queues.steer)
+                agent.steer(message);
+            for (const message of queues.followUp)
+                agent.followUp(message);
+            for (const kind of ["steer", "followUp"]) {
+                mirrors[kind].splice(0, mirrors[kind].length, ...remaining.filter((entry) => entry.kind === kind && entry.message !== undefined).map((entry) => entry.text));
+            }
+        }
+        catch (error) {
+            // Best-effort rollback when a callable SDK method fails during replacement.
+            // Restoration itself can fail after an incompatible behavioral change.
+            const failures = [error];
+            try {
+                agent.clearAllQueues();
+                for (const message of originalQueues.steer)
+                    agent.steer(message);
+                for (const message of originalQueues.followUp)
+                    agent.followUp(message);
+            }
+            catch (restoreError) {
+                failures.push(restoreError);
+            }
+            for (const kind of ["steer", "followUp"]) {
+                try {
+                    mirrors[kind].splice(0, mirrors[kind].length, ...originalMirrors[kind]);
+                }
+                catch (restoreError) {
+                    failures.push(restoreError);
+                }
+            }
+            throw new AggregateError(failures, "Could not replace SDK queues; attempted to restore their original contents", { cause: error });
+        }
+        if (held.length === 0)
+            this.clearCompactionPromptQueue(session.sessionId);
+        else
+            this.compactionPromptQueues.set(session.sessionId, held);
+    }
     async clearQueue(ref) {
         await this.assertWritable(ref);
         const session = await this.getOrOpen(ref);
@@ -3644,16 +3766,25 @@ export class PiSessionService {
                 return;
             this.publishStatus(session);
             for (const prompt of queued)
-                void this.submitPrompt(session, prompt.text, prompt.kind, prompt.images, prompt.echoUserMessage ?? true);
+                void this.submitHeldPrompt(session, prompt, prompt.kind);
             return;
         }
         const prompt = this.shiftCompactionPrompt(sessionId);
         if (prompt === undefined)
             return;
         this.publishStatus(session);
-        const submitted = this.submitPrompt(session, prompt.text, undefined, prompt.images, prompt.echoUserMessage ?? true);
+        const submitted = this.submitHeldPrompt(session, prompt);
         void submitted.finally(() => { this.scheduleCompactionQueueDrain(sessionId); });
     }
+    submitHeldPrompt(session, prompt, kind) {
+        if (prompt.message === undefined)
+            return this.submitPrompt(session, prompt.text, kind, prompt.images, prompt.echoUserMessage ?? true);
+        // Use the public session API even after the queue adapter has been disabled.
+        // Keep auth, run ownership and settlement SDK-owned; text is already expanded.
+        const images = prompt.message.role === "user" && Array.isArray(prompt.message.content)
+            ? prompt.message.content.filter((part) => part.type === "image") : [];
+        return this.beginPromptSubmission(session, prompt.text, kind, images, true, false).catch(() => undefined);
+    }
     takeCompactionPromptQueue(sessionId) {
         const queued = this.compactionPromptQueues.get(sessionId) ?? [];
         this.compactionPromptQueues.delete(sessionId);
@@ -3661,7 +3792,8 @@ export class PiSessionService {
     }
     shiftCompactionPrompt(sessionId) {
         const queue = this.compactionPromptQueues.get(sessionId);
-        const prompt = queue?.shift();
+        const steeringIndex = queue?.findIndex((prompt) => prompt.kind === "steer") ?? -1;
+        const prompt = queue?.splice(steeringIndex < 0 ? 0 : steeringIndex, 1)[0];
         if (queue === undefined || queue.length === 0)
             this.compactionPromptQueues.delete(sessionId);
         return prompt;
@@ -4038,6 +4170,8 @@ export class PiSessionService {
         const warnings = this.warningsForSession(session);
         const pendingDialogs = this.pendingExtensionDialogStore.pendingDialogs(session.sessionId);
         const suggestedInput = this.suggestedInputs.get(session.sessionId);
+        const queuedMessages = this.queuedMessages(session);
+        const queueMessageActionsUnavailable = this.queueCompatibility.reason(session);
         return {
             sessionId: session.sessionId,
             persisted: sessionFileExists(session.sessionFile),
@@ -4048,7 +4182,8 @@ export class PiSessionService {
             isCompacting: session.isCompacting,
             isBashRunning: session.isBashRunning,
             pendingMessageCount: this.pendingMessageCount(session),
-            queuedMessages: queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)),
+            queuedMessages,
+            ...(queueMessageActionsUnavailable === undefined ? {} : { queueMessageActionsUnavailable }),
             messageCount,
             tokens: stats.tokens,
             cost: stats.cost,
@@ -4078,8 +4213,12 @@ export class PiSessionService {
     compactionQueuedMessages(sessionId) {
         return this.compactionPromptQueues.get(sessionId) ?? [];
     }
+    queuedMessages(session) {
+        const held = this.compactionQueuedMessages(session.sessionId);
+        return this.queueCompatibility.inspect(session, () => queuedMessagesFromSession(session, held), () => queuedMessagesFromSession(session, held, false));
+    }
     hasQueuedMessageText(session, text) {
-        return queuedMessagesFromSession(session, this.compactionQueuedMessages(session.sessionId)).some((message) => message.text === text);
+        return this.queuedMessages(session).some((message) => message.text === text);
     }
 }
 function previewResponseFromPlan(plan) {
@@ -4462,12 +4601,37 @@ function clearParentSessionHeader(sessionManager) {
 function clearSessionQueue(session) {
     session.clearQueue();
 }
-function queuedMessagesFromSession(session, extraQueuedMessages = []) {
-    return [
-        ...session.getSteeringMessages().map((text) => ({ kind: "steer", text })),
-        ...session.getFollowUpMessages().map((text) => ({ kind: "followUp", text })),
-        ...extraQueuedMessages,
-    ];
+function queuedMessagesFromSession(session, extraQueuedMessages = [], inspectSdk = true) {
+    const texts = inspectSdk
+        ? { steer: mutableTextMirror(session.getSteeringMessages()), followUp: mutableTextMirror(session.getFollowUpMessages()) }
+        : { steer: publicQueueTexts(() => session.getSteeringMessages()), followUp: publicQueueTexts(() => session.getFollowUpMessages()) };
+    const attachmentCounts = { steer: [], followUp: [] };
+    if (inspectSdk && (texts.steer.length > 0 || texts.followUp.length > 0 || extraQueuedMessages.length > 0)) {
+        const queues = snapshotAgentQueues(mutableQueueAgent(session.agent));
+        for (const kind of ["steer", "followUp"]) {
+            attachmentCounts[kind] = queuedMessageAttachmentCounts(queues[kind], texts[kind]);
+        }
+    }
+    return ["steer", "followUp"].flatMap((kind) => [
+        ...texts[kind].map((text, index) => ({ kind, text, ...queuedAttachmentMetadata(attachmentCounts[kind][index] ?? 0) })),
+        ...extraQueuedMessages.filter((message) => message.kind === kind).map((prompt) => ({
+            kind, text: prompt.text,
+            ...queuedAttachmentMetadata(prompt.message === undefined ? prompt.images?.length ?? 0 : queuedMessageAttachmentCount(prompt.message)),
+        })),
+    ]);
+}
+/** Degraded status still uses public text getters where their values are usable. */
+function publicQueueTexts(read) {
+    try {
+        const value = read();
+        return Array.isArray(value) ? value.filter((text) => typeof text === "string") : [];
+    }
+    catch {
+        return [];
+    } // The compatibility guard already records the original failure.
+}
+function queuedAttachmentMetadata(attachmentCount) {
+    return attachmentCount > 0 ? { hasAttachments: true, attachmentCount } : {};
 }
 function userTextMessage(text) {
     return { role: "user", content: text };