openfox 2.0.133 → 2.0.134

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

@@ -2,29 +2,32 @@ import {
   generateSessionNameForSession,
   getSessionMessageCount,
   needsNameGeneration
-} from "./chunk-RRUSYVQD.js";
+} from "./chunk-FAQDLL2X.js";
 import {
   launchWorkflowRun
-} from "./chunk-P5MSY7ZI.js";
+} from "./chunk-7HGBJFIJ.js";
 import {
   runChatTurn
-} from "./chunk-GFW2HWJ6.js";
+} from "./chunk-YOPXAI2W.js";
 import {
   devServerManager
-} from "./chunk-HXHPKGJE.js";
+} from "./chunk-J5HOUEPE.js";
 import {
   gitSpawnEnv
 } from "./chunk-J7GAZGZT.js";
+import {
+  serverT
+} from "./chunk-OZWHRBDY.js";
 import {
   appendCompactionPrompt
-} from "./chunk-ZL4IAFF3.js";
+} from "./chunk-BZND27IB.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-QICVOQNX.js";
 import {
   getPendingQuestionsForSession,
   provideAnswer
@@ -40,14 +43,14 @@ import {
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-FGNJMKDV.js";
+} from "./chunk-CSYOWFPU.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-WKEXQCTK.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-WWIWD3O7.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-M4J2L4VH.js.map

package/dist/{chunk-M5T4RDPJ.js → chunk-MEEUXRFL.js}

@@ -1,6 +1,6 @@
 import {
   resolveDefaultAgentId
-} from "./chunk-ELYHHEYL.js";
+} from "./chunk-ORCQ3EXQ.js";
 import {
   normalizeAskOptions
 } from "./chunk-LCLH6ZUL.js";
@@ -965,4 +965,4 @@ export {
   buildSnapshot,
   buildSnapshotFromSessionState
 };
-//# sourceMappingURL=chunk-M5T4RDPJ.js.map
+//# sourceMappingURL=chunk-MEEUXRFL.js.map

package/dist/{chunk-OMMPTN6X.js → chunk-MRE4OYKI.js}

@@ -4,13 +4,19 @@ import {
   password,
   select
 } from "./chunk-AGXJ5O63.js";
+import {
+  cliT,
+  setCliMode
+} from "./chunk-2OMGR7LN.js";
 
 // src/cli/main.ts
 import { parseArgs } from "util";
 import { generateKeyPairSync } from "crypto";
 import { writeFile } from "fs/promises";
 function printHelp() {
-  console.log(`
+  console.log(
+    cliT({
+      en: `
 OpenFox - Local LLM coding assistant
 
 Usage:
@@ -34,7 +40,34 @@ Options:
   --no-browser            Don't open browser on start
   -h, --help              Show this help message
   -v, --version           Show version number
-`);
+`,
+      fr: `
+OpenFox - Assistant de codage LLM local
+
+Utilisation :
+  openfox [commande] [options]
+
+Commandes :
+  (aucune)        D\xE9marrer le serveur pour le projet courant
+  config          Afficher la configuration actuelle
+  provider add    Ajouter un nouveau fournisseur LLM
+  provider list   Lister les fournisseurs configur\xE9s
+  provider use    Changer de fournisseur actif
+  provider remove Supprimer un fournisseur
+  service         G\xE9rer le service systemd (install, start, stop, status, logs, uninstall)
+  pwa             G\xE9rer l\u2019installation PWA (install, uninstall, launch, update, status)
+  mcp             Afficher une configuration MCP pr\xEAte \xE0 coller pour ce serveur (demande le mot de passe s\u2019il est d\xE9fini)
+  install         Installer un lanceur OpenFox persistant (utiliser --check pour inspecter)
+  update          Mettre OpenFox \xE0 jour vers la derni\xE8re version
+
+Options :
+  -p, --port <nombre>    Sp\xE9cifier le port (d\xE9faut : 10369 pour prod, 10469 pour dev)
+  --no-browser           Ne pas ouvrir le navigateur au d\xE9marrage
+  -h, --help             Afficher ce message d\u2019aide
+  -v, --version          Afficher le num\xE9ro de version
+`
+    })
+  );
 }
 async function runNetworkSetup(mode) {
   const { loadAuthConfig, saveAuthConfig, encryptPassword } = await import("./auth-D3WLIBTG.js");
@@ -44,12 +77,15 @@ async function runNetworkSetup(mode) {
   if (existingAuth) {
     return;
   }
-  console.log("\nOpenFox Setup\n");
+  console.log(cliT({ en: "\nOpenFox Setup\n", fr: "\nConfiguration d\u2019OpenFox\n" }));
   const networkChoice = await select({
-    message: "How should OpenFox be accessible?",
+    message: cliT({ en: "How should OpenFox be accessible?", fr: "Comment OpenFox doit-il \xEAtre accessible ?" }),
     options: [
-      { value: "localhost", label: "Secure (localhost only)" },
-      { value: "network", label: "Accessible from local network" }
+      { value: "localhost", label: cliT({ en: "Secure (localhost only)", fr: "S\xE9curis\xE9 (localhost uniquement)" }) },
+      {
+        value: "network",
+        label: cliT({ en: "Accessible from local network", fr: "Accessible depuis le r\xE9seau local" })
+      }
     ]
   });
   if (isCancel(networkChoice)) {
@@ -61,7 +97,10 @@ async function runNetworkSetup(mode) {
   let passwordValue;
   if (isNetwork) {
     const pwd = await password({
-      message: "Set a password? (optional, press Enter to skip)"
+      message: cliT({
+        en: "Set a password? (optional, press Enter to skip)",
+        fr: "D\xE9finir un mot de passe ? (facultatif, Entr\xE9e pour ignorer)"
+      })
     });
     if (isCancel(pwd)) {
       cancel();
@@ -102,7 +141,7 @@ async function runNetworkSetup(mode) {
       backend: "ollama"
     }
   });
-  console.log("\u2713 Configuration saved!\n");
+  console.log(cliT({ en: "\u2713 Configuration saved!\n", fr: "\u2713 Configuration enregistr\xE9e !\n" }));
 }
 async function runConfig(mode) {
   const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-LOK3LXFH.js");
@@ -111,24 +150,27 @@ async function runConfig(mode) {
   const configPath = getGlobalConfigPath(mode);
   const activeProvider = getActiveProvider(config);
   const defaultModel = getDefaultModel(config);
-  console.log(`Configuration (${mode}):`);
-  console.log(`  Location: ${configPath}`);
-  console.log(`  Providers: ${config.providers.length}`);
+  console.log(cliT({ en: `Configuration (${mode}):`, fr: `Configuration (${mode}) :` }));
+  console.log(cliT({ en: `  Location: ${configPath}`, fr: `  Emplacement : ${configPath}` }));
+  console.log(
+    cliT({ en: `  Providers: ${config.providers.length}`, fr: `  Fournisseurs : ${config.providers.length}` })
+  );
   if (activeProvider) {
-    console.log(`  Active: ${activeProvider.name}`);
-    console.log(`    URL: ${activeProvider.url}`);
-    console.log(`    Model: ${defaultModel ?? "auto"}`);
-    console.log(`    Backend: ${activeProvider.backend}`);
+    console.log(cliT({ en: `  Active: ${activeProvider.name}`, fr: `  Actif : ${activeProvider.name}` }));
+    console.log(cliT({ en: `    URL: ${activeProvider.url}`, fr: `    URL : ${activeProvider.url}` }));
+    console.log(cliT({ en: `    Model: ${defaultModel ?? "auto"}`, fr: `    Mod\xE8le : ${defaultModel ?? "auto"}` }));
+    console.log(cliT({ en: `    Backend: ${activeProvider.backend}`, fr: `    Backend : ${activeProvider.backend}` }));
   } else {
-    console.log(`  Active: (none configured)`);
+    console.log(cliT({ en: `  Active: (none configured)`, fr: `  Actif : (aucun configur\xE9)` }));
   }
   const host = config.server.host ?? "127.0.0.1";
-  const hostDisplay = host === "0.0.0.0" ? `${host} (accessible from local network)` : `${host} (localhost only)`;
-  console.log(`  Server: ${hostDisplay}`);
-  console.log(`  Port: ${config.server.port}`);
+  const hostDisplay = host === "0.0.0.0" ? cliT({ en: `${host} (accessible from local network)`, fr: `${host} (accessible depuis le r\xE9seau local)` }) : cliT({ en: `${host} (localhost only)`, fr: `${host} (localhost uniquement)` });
+  console.log(cliT({ en: `  Server: ${hostDisplay}`, fr: `  Serveur : ${hostDisplay}` }));
+  console.log(cliT({ en: `  Port: ${config.server.port}`, fr: `  Port : ${config.server.port}` }));
 }
 async function runCli(options) {
   const { mode } = options;
+  setCliMode(mode);
   const { values, positionals } = parseArgs({
     options: {
       port: { type: "string", short: "p" },
@@ -165,13 +207,13 @@ async function runCli(options) {
       break;
     }
     case "provider": {
-      const { runProviderCommand } = await import("./provider-NWRGNGS3.js");
+      const { runProviderCommand } = await import("./provider-JWUNG2TD.js");
       const [, subcommand] = positionals;
       await runProviderCommand(mode, subcommand);
       break;
     }
     case "service": {
-      const { runServiceCommand } = await import("./service-WKABQHKL.js");
+      const { runServiceCommand } = await import("./service-M77VWL2M.js");
       const [, subcommand, ...serviceArgs] = positionals;
       if (values.follow) {
         serviceArgs.push("-f");
@@ -184,7 +226,7 @@ async function runCli(options) {
       break;
     }
     case "pwa": {
-      const { runPwaCommand, printPwaHelp } = await import("./pwa-2GRFSXD7.js");
+      const { runPwaCommand, printPwaHelp } = await import("./pwa-V5PFB4OQ.js");
       const [, subcommand] = positionals;
       if (subcommand === "--help" || subcommand === "-h" || values.help) {
         printPwaHelp();
@@ -194,7 +236,7 @@ async function runCli(options) {
       break;
     }
     case "mcp": {
-      const { runMcpCommand } = await import("./mcp-YU7AM3UV.js");
+      const { runMcpCommand } = await import("./mcp-SQ4DOGPT.js");
       const mcpOptions = {};
       if (values.password) mcpOptions.password = values.password;
       if (values.port) mcpOptions.port = parseInt(values.port);
@@ -202,7 +244,7 @@ async function runCli(options) {
       break;
     }
     case "install": {
-      const { runInstall } = await import("./install-VA2F6X6Z.js");
+      const { runInstall } = await import("./install-AVTFA344.js");
       const code = await runInstall({ check: values.check === true });
       if (code !== 0) {
         process.exit(code);
@@ -210,7 +252,7 @@ async function runCli(options) {
       break;
     }
     case "update": {
-      const { runUpdate } = await import("./update-VC3Y3EOP.js");
+      const { runUpdate } = await import("./update-Q6SH7UP2.js");
       const code = await runUpdate();
       if (code !== 0) {
         process.exit(code);
@@ -223,7 +265,7 @@ async function runCli(options) {
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-XRVT3D7Z.js");
+      const { runServe } = await import("./serve-HSDVY37K.js");
       const serveOptions = { mode };
       if (values.port) serveOptions.port = parseInt(values.port);
       if (values["no-browser"] === true) serveOptions.openBrowser = false;
@@ -235,4 +277,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-OMMPTN6X.js.map
+//# sourceMappingURL=chunk-MRE4OYKI.js.map

package/dist/{chunk-MGEYAYGU.js → chunk-O3RCSKUH.js}

@@ -1,7 +1,7 @@
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-LQKXJPKP.js";
+} from "./chunk-CTWZPN7G.js";
 
 // src/server/utils/platform.ts
 import os from "os";
@@ -63,4 +63,4 @@ export {
   isWindowsPath,
   isAbsolutePath
 };
-//# sourceMappingURL=chunk-MGEYAYGU.js.map
+//# sourceMappingURL=chunk-O3RCSKUH.js.map

package/dist/{chunk-ELYHHEYL.js → chunk-ORCQ3EXQ.js}

@@ -7,7 +7,7 @@ import {
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-LQKXJPKP.js";
+} from "./chunk-CTWZPN7G.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -352,4 +352,4 @@ export {
   getOverrideAgentIds,
   resolveDefaultAgentId
 };
-//# sourceMappingURL=chunk-ELYHHEYL.js.map
+//# sourceMappingURL=chunk-ORCQ3EXQ.js.map