openfox 2.0.133 → 2.0.135

package/dist/{chunk-KWAHD2JA.js → chunk-F2MOHHXB.js}

@@ -1,6 +1,6 @@
 import {
   resolveDefaultAgentId
-} from "./chunk-ELYHHEYL.js";
+} from "./chunk-ORCQ3EXQ.js";
 import {
   getDatabase
 } from "./chunk-JU757HVI.js";
@@ -240,6 +240,18 @@ function updateSessionMessageCount(id, delta) {
   } catch {
   }
 }
+function setSessionMessageCount(id, count) {
+  try {
+    const db = getDatabase();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    db.prepare(
+      `
+      UPDATE sessions SET message_count = ?, updated_at = ? WHERE id = ?
+    `
+    ).run(count, now, id);
+  } catch {
+  }
+}
 function getSessionMessageCount(id) {
   try {
     const db = getDatabase();
@@ -456,6 +468,7 @@ export {
   updateSessionCachedPrompt,
   getSessionCachedPrompt,
   updateSessionMessageCount,
+  setSessionMessageCount,
   getSessionMessageCount,
   listSessions,
   listSessionsByProject,
@@ -471,4 +484,4 @@ export {
   getLatestWorkflowExecution,
   clearWorkflowExecution
 };
-//# sourceMappingURL=chunk-KWAHD2JA.js.map
+//# sourceMappingURL=chunk-F2MOHHXB.js.map

package/dist/{chunk-A7CB4USC.js → chunk-GP3CLMPQ.js}

@@ -2,29 +2,32 @@ import {
   generateSessionNameForSession,
   getSessionMessageCount,
   needsNameGeneration
-} from "./chunk-RRUSYVQD.js";
+} from "./chunk-NFEZATSN.js";
 import {
   launchWorkflowRun
-} from "./chunk-P5MSY7ZI.js";
+} from "./chunk-5H5NRWHA.js";
 import {
   runChatTurn
-} from "./chunk-GFW2HWJ6.js";
+} from "./chunk-4R5GV7RW.js";
 import {
   devServerManager
-} from "./chunk-HXHPKGJE.js";
+} from "./chunk-ESZQTFQP.js";
 import {
   gitSpawnEnv
 } from "./chunk-J7GAZGZT.js";
+import {
+  serverT
+} from "./chunk-OZWHRBDY.js";
 import {
   appendCompactionPrompt
-} from "./chunk-ZL4IAFF3.js";
+} from "./chunk-UKIUQAQZ.js";
 import {
   hasRecentLLMFailure,
   interruptLLMRetryWait
 } from "./chunk-7ET46SNE.js";
 import {
   onProcessEvent
-} from "./chunk-MQMPIXON.js";
+} from "./chunk-5UMXFLET.js";
 import {
   killProcessTree
 } from "./chunk-I72ACQ6R.js";
@@ -32,7 +35,7 @@ import {
   applyDynamicContext,
   computeSessionHash,
   computeUnifiedDiff
-} from "./chunk-VXG3AFFY.js";
+} from "./chunk-VHLD6PCZ.js";
 import {
   getPendingQuestionsForSession,
   provideAnswer
@@ -40,14 +43,14 @@ import {
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-FGNJMKDV.js";
+} from "./chunk-QZOV4OVN.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-M5T4RDPJ.js";
+} from "./chunk-MEEUXRFL.js";
 import {
   getRuntimeConfig
-} from "./chunk-ELYHHEYL.js";
+} from "./chunk-ORCQ3EXQ.js";
 import {
   createChatErrorMessage,
   createChatMessageMessage,
@@ -62,19 +65,19 @@ import {
   parseClientMessage,
   serializeServerMessage,
   storedEventToServerMessage
-} from "./chunk-P57IBMK4.js";
+} from "./chunk-AATMPL7S.js";
 import {
   getPlatformShell
-} from "./chunk-MGEYAYGU.js";
+} from "./chunk-O3RCSKUH.js";
 import {
   getMaxVisibleItems
-} from "./chunk-LQKXJPKP.js";
+} from "./chunk-CTWZPN7G.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
 import {
   createServerMessage
-} from "./chunk-HCYSGLY2.js";
+} from "./chunk-HF3NDXB4.js";
 
 // src/server/ws/server.ts
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
@@ -472,6 +475,14 @@ async function isValidToken(token) {
 }
 
 // src/server/ws/server.ts
+var MSG_INVALID_MESSAGE_FORMAT = { en: "Invalid message format", fr: "Format de message invalide" };
+var MSG_NO_ACTIVE_SESSION = { en: "No active session", fr: "Aucune session active" };
+var MSG_SESSION_NOT_FOUND = { en: "Session not found", fr: "Session introuvable" };
+var MSG_SESSION_IS_RUNNING = {
+  en: "Session is already running",
+  fr: "La session est d\xE9j\xE0 en cours d\u2019ex\xE9cution"
+};
+var MSG_UNKNOWN_ERROR = { en: "Unknown error", fr: "Erreur inconnue" };
 var resolveMcpReady = null;
 var mcpReadyPromise = new Promise((resolve) => {
   resolveMcpReady = resolve;
@@ -1023,7 +1034,7 @@ function createWebSocketServer(httpServer, _config, getLLMClient, getActiveProvi
         const seq = client2.lastSentSeq + 1;
         enqueueSend(
           client2,
-          serializeServerMessage(createErrorMessage("INVALID_MESSAGE", "Invalid message format")),
+          serializeServerMessage(createErrorMessage("INVALID_MESSAGE", serverT(MSG_INVALID_MESSAGE_FORMAT))),
           seq
         );
         return;
@@ -1059,7 +1070,11 @@ function createWebSocketServer(httpServer, _config, getLLMClient, getActiveProvi
         enqueueSend(
           client2,
           serializeServerMessage(
-            createErrorMessage("INTERNAL_ERROR", error instanceof Error ? error.message : "Unknown error", message.id)
+            createErrorMessage(
+              "INTERNAL_ERROR",
+              error instanceof Error ? error.message : serverT(MSG_UNKNOWN_ERROR),
+              message.id
+            )
           ),
           seq
         );
@@ -1150,12 +1165,18 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
     // =========================================================================
     case "session.load": {
       if (!isSessionLoadPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid session.load payload", message.id));
+        send(
+          createErrorMessage(
+            "INVALID_PAYLOAD",
+            serverT({ en: "Invalid session.load payload", fr: "Payload de session.load invalide" }),
+            message.id
+          )
+        );
         return;
       }
       const session = sessionManager.getSession(message.payload.sessionId);
       if (!session) {
-        send(createErrorMessage("NOT_FOUND", "Session not found", message.id));
+        send(createErrorMessage("NOT_FOUND", serverT(MSG_SESSION_NOT_FOUND), message.id));
         return;
       }
       client.activeSessionId = session.id;
@@ -1208,12 +1229,21 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       const payload = message.payload;
       const sessionId = payload?.sessionId ?? client.activeSessionId;
       if (!sessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const session = sessionManager.requireSession(sessionId);
       if (session.isRunning) {
-        send(createErrorMessage("SESSION_RUNNING", "Cannot compact while session is running", message.id));
+        send(
+          createErrorMessage(
+            "SESSION_RUNNING",
+            serverT({
+              en: "Cannot compact while session is running",
+              fr: "Impossible de compacter pendant que la session est en cours"
+            }),
+            message.id
+          )
+        );
         return;
       }
       send({ type: "ack", payload: {}, id: message.id });
@@ -1240,10 +1270,11 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       }).catch((error) => {
         if (error instanceof Error && error.message === "Aborted") return;
         logger.error("Compaction failed", { error, sessionId });
+        const reason = error instanceof Error ? error.message : serverT(MSG_UNKNOWN_ERROR);
         sendForSession(
           sessionId,
           createChatErrorMessage(
-            `Compaction failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+            serverT({ en: "Compaction failed: {{reason}}", fr: "\xC9chec de la compaction : {{reason}}" }, { reason }),
             true
           )
         );
@@ -1267,7 +1298,7 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
     }
     case "context.checkDynamic": {
       if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const sessionId = client.activeSessionId;
@@ -1308,13 +1339,13 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       const payload = message.payload;
       const sessionId = payload?.sessionId ?? client.activeSessionId;
       if (!sessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const session = sessionManager.requireSession(sessionId);
       try {
-        const { buildCachedPrompt, computePreviewToolDiff } = await import("./dynamic-context-NJZKAZE3.js");
-        const allAgents = await import("./registry-CMSSZHDC.js");
+        const { buildCachedPrompt, computePreviewToolDiff } = await import("./dynamic-context-LKC6JYLQ.js");
+        const allAgents = await import("./registry-BEIR7Y5G.js");
         const agentDef = allAgents.findAgentById(session.mode, await allAgents.loadAllAgentsDefault()) ?? allAgents.findAgentById("planner", await allAgents.loadAllAgentsDefault());
         const modelName = session.providerModel ?? _providerManager?.getCurrentModel();
         const {
@@ -1325,7 +1356,7 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
         const oldCached = sessionManager.getCachedPrompt(sessionId);
         const oldPrompt = oldCached?.systemPrompt;
         const diff = oldPrompt ? computeUnifiedDiff(oldPrompt, newPrompt) : [];
-        const { getToolRegistryForAgent } = await import("./tools-CW6POKUL.js");
+        const { getToolRegistryForAgent } = await import("./tools-E63MOJBO.js");
         const unfilteredTools = getToolRegistryForAgent(agentDef).definitions;
         const toolDiff = computePreviewToolDiff(oldCached?.tools, unfilteredTools, newTools);
         send({
@@ -1345,10 +1376,11 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
           error: error instanceof Error ? error.message : "Unknown error",
           sessionId
         });
+        const reason = error instanceof Error ? error.message : serverT(MSG_UNKNOWN_ERROR);
         send(
           createErrorMessage(
             "ERROR",
-            `Failed to preview: ${error instanceof Error ? error.message : "Unknown error"}`,
+            serverT({ en: "Failed to preview: {{reason}}", fr: "\xC9chec de l\u2019aper\xE7u : {{reason}}" }, { reason }),
             message.id
           )
         );
@@ -1359,12 +1391,21 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       const payload = message.payload;
       const sessionId = payload?.sessionId ?? client.activeSessionId;
       if (!sessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const session = sessionManager.requireSession(sessionId);
       if (session.isRunning) {
-        send(createErrorMessage("SESSION_RUNNING", "Cannot apply dynamic context while session is running", message.id));
+        send(
+          createErrorMessage(
+            "SESSION_RUNNING",
+            serverT({
+              en: "Cannot apply dynamic context while session is running",
+              fr: "Impossible d\u2019appliquer le contexte dynamique pendant que la session est en cours"
+            }),
+            message.id
+          )
+        );
         return;
       }
       ;
@@ -1377,10 +1418,17 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
           send({ type: "ack", payload: {}, id: message.id });
         } catch (error) {
           logger.error("Failed to apply dynamic context", { error, sessionId });
+          const reason = error instanceof Error ? error.message : serverT(MSG_UNKNOWN_ERROR);
           sendForSession(
             sessionId,
             createChatErrorMessage(
-              `Failed to apply dynamic context: ${error instanceof Error ? error.message : "Unknown error"}`,
+              serverT(
+                {
+                  en: "Failed to apply dynamic context: {{reason}}",
+                  fr: "\xC9chec d\u2019application du contexte dynamique : {{reason}}"
+                },
+                { reason }
+              ),
               true
             )
           );
@@ -1396,7 +1444,7 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       const launchPayloadEarly = message.payload;
       const sessionId = launchPayloadEarly?.sessionId ?? client.activeSessionId;
       if (!sessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const session = sessionManager.requireSession(sessionId);
@@ -1424,7 +1472,13 @@ ${content}` : workflowInfo;
       if (!launchPayloadEarly?.resumeFrom) {
         const pendingCriteria = session.criteria.filter((c) => c.status.type !== "passed");
         if (!launchPayloadEarly?.workflowId && pendingCriteria.length === 0) {
-          send(createErrorMessage("NO_WORK", "No pending criteria to work on", message.id));
+          send(
+            createErrorMessage(
+              "NO_WORK",
+              serverT({ en: "No pending criteria to work on", fr: "Aucun crit\xE8re en attente sur lequel travailler" }),
+              message.id
+            )
+          );
           return;
         }
       }
@@ -1511,17 +1565,29 @@ ${content}` : workflowInfo;
     // =========================================================================
     case "ask.answer": {
       if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       if (!isAskAnswerPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid ask.answer payload", message.id));
+        send(
+          createErrorMessage(
+            "INVALID_PAYLOAD",
+            serverT({ en: "Invalid ask.answer payload", fr: "Payload ask.answer invalide" }),
+            message.id
+          )
+        );
         return;
       }
       const { callId, answer, skip } = message.payload;
       const found = provideAnswer(callId, answer, skip);
       if (!found) {
-        send(createErrorMessage("NOT_FOUND", "No pending question with that ID", message.id));
+        send(
+          createErrorMessage(
+            "NOT_FOUND",
+            serverT({ en: "No pending question with that ID", fr: "Aucune question en attente avec cet ID" }),
+            message.id
+          )
+        );
         return;
       }
       logger.debug("Ask user answer received", {
@@ -1539,12 +1605,12 @@ ${content}` : workflowInfo;
       const payload = message.payload;
       const exitSessionId = payload?.sessionId ?? client.activeSessionId;
       if (!exitSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const exitSession = sessionManager.getSession(exitSessionId);
       if (!exitSession) {
-        send(createErrorMessage("NOT_FOUND", "Session not found", message.id));
+        send(createErrorMessage("NOT_FOUND", serverT(MSG_SESSION_NOT_FOUND), message.id));
         return;
       }
       const activeExec = sessionManager.getActiveWorkflowExecution(exitSessionId);
@@ -1577,7 +1643,7 @@ ${content}` : workflowInfo;
       const payload = message.payload;
       const retrySessionId = payload?.sessionId ?? client.activeSessionId;
       if (!retrySessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const interrupted = interruptLLMRetryWait(retrySessionId);
@@ -1588,25 +1654,37 @@ ${content}` : workflowInfo;
       const payload = message.payload;
       const retrySessionId = payload?.sessionId ?? client.activeSessionId;
       if (!retrySessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
+        send(createErrorMessage("NO_SESSION", serverT(MSG_NO_ACTIVE_SESSION), message.id));
         return;
       }
       const retrySession = sessionManager.getSession(retrySessionId);
       if (!retrySession) {
-        send(createErrorMessage("NOT_FOUND", "Session not found", message.id));
+        send(createErrorMessage("NOT_FOUND", serverT(MSG_SESSION_NOT_FOUND), message.id));
         return;
       }
       if (retrySession.isRunning) {
-        send(createErrorMessage("SESSION_RUNNING", "Session is already running", message.id));
+        send(createErrorMessage("SESSION_RUNNING", serverT(MSG_SESSION_IS_RUNNING), message.id));
         return;
       }
       if (!hasRecentLLMFailure(retrySessionId, 30 * 6e4)) {
-        send(createErrorMessage("NO_FAILED_TURN", "No failed turn to retry", message.id));
+        send(
+          createErrorMessage(
+            "NO_FAILED_TURN",
+            serverT({ en: "No failed turn to retry", fr: "Aucun tour \xE9chou\xE9 \xE0 relancer" }),
+            message.id
+          )
+        );
         return;
       }
       const latestExec = sessionManager.getLatestWorkflowExecution(retrySessionId);
       if (latestExec && (latestExec.status === "blocked" || latestExec.status === "running" || latestExec.status === "waiting")) {
-        send(createErrorMessage("WORKFLOW_ACTIVE", "A workflow run is active", message.id));
+        send(
+          createErrorMessage(
+            "WORKFLOW_ACTIVE",
+            serverT({ en: "A workflow run is active", fr: "Un run de workflow est actif" }),
+            message.id
+          )
+        );
         return;
       }
       if (retrySession.phase === "blocked") {
@@ -1624,7 +1702,16 @@ ${content}` : workflowInfo;
       break;
     }
     default: {
-      send(createErrorMessage("UNKNOWN_MESSAGE", `Unknown message type: ${message.type}`, message.id));
+      send(
+        createErrorMessage(
+          "UNKNOWN_MESSAGE",
+          serverT(
+            { en: "Unknown message type: {{type}}", fr: "Type de message inconnu : {{type}}" },
+            { type: message.type }
+          ),
+          message.id
+        )
+      );
     }
   }
 }
@@ -1642,4 +1729,4 @@ export {
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-A7CB4USC.js.map
+//# sourceMappingURL=chunk-GP3CLMPQ.js.map

package/dist/{chunk-HCYSGLY2.js → chunk-HF3NDXB4.js}

@@ -26,4 +26,4 @@ export {
   isClientMessage,
   isServerMessage
 };
-//# sourceMappingURL=chunk-HCYSGLY2.js.map
+//# sourceMappingURL=chunk-HF3NDXB4.js.map

package/dist/{chunk-Y6ZGHOKM.js → chunk-I5ODJKYM.js}

@@ -1,12 +1,12 @@
 import {
   getEventStore
-} from "./chunk-FGNJMKDV.js";
+} from "./chunk-QZOV4OVN.js";
 import {
   createChatPathConfirmationMessage
-} from "./chunk-P57IBMK4.js";
+} from "./chunk-AATMPL7S.js";
 import {
   getPlatformShell
-} from "./chunk-MGEYAYGU.js";
+} from "./chunk-O3RCSKUH.js";
 
 // src/server/tools/path-security.ts
 import { realpath } from "fs/promises";
@@ -782,4 +782,4 @@ export {
   getConfirmationSessionId,
   getPendingConfirmationsBySession
 };
-//# sourceMappingURL=chunk-Y6ZGHOKM.js.map
+//# sourceMappingURL=chunk-I5ODJKYM.js.map