openfox 2.0.133 → 2.0.135

package/dist/pwa-V5PFB4OQ.js

@@ -0,0 +1,502 @@
+import {
+  cancel,
+  confirm,
+  isCancel,
+  log
+} from "./chunk-AGXJ5O63.js";
+import {
+  cliT
+} from "./chunk-2OMGR7LN.js";
+import "./chunk-24YKXKCG.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
+import "./chunk-YLJ4XMA6.js";
+
+// src/cli/pwa.ts
+import { execSync, spawn } from "child_process";
+import { join } from "path";
+import { readFile, writeFile, access, mkdir } from "fs/promises";
+import { platform } from "os";
+var PWA_CONFIG_FILE = "pwa.json";
+function execSyncSilent(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+  } catch {
+    return "";
+  }
+}
+function execSyncOk(cmd) {
+  try {
+    execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isFirefoxPwaAvailable() {
+  if (platform() === "win32") {
+    return execSyncOk("where firefoxpwa");
+  }
+  return execSyncOk("which firefoxpwa");
+}
+function isRuntimeInstalled() {
+  const out = execSyncSilent("firefoxpwa runtime --help");
+  return out.includes("uninstall");
+}
+function getManifestUrl(mode) {
+  const port = mode === "development" ? 10469 : 10369;
+  return `http://127.0.0.1:${port}/manifest.webmanifest`;
+}
+function getPwaConfigPath(mode) {
+  return join(getGlobalConfigDir(mode), PWA_CONFIG_FILE);
+}
+async function loadPwaConfig(mode) {
+  try {
+    const content = await readFile(getPwaConfigPath(mode), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function savePwaConfig(mode, config) {
+  await mkdir(getGlobalConfigDir(mode), { recursive: true });
+  await writeFile(getPwaConfigPath(mode), JSON.stringify(config, null, 2));
+}
+async function removePwaConfig(mode) {
+  try {
+    await access(getPwaConfigPath(mode));
+  } catch {
+    return;
+  }
+  const { unlink } = await import("fs/promises");
+  await unlink(getPwaConfigPath(mode));
+}
+function getFirefoxPwaInstallHint() {
+  const plat = platform();
+  switch (plat) {
+    case "darwin":
+      return "brew install firefoxpwa";
+    case "win32":
+      return "scoop install extras/firefoxpwa   # or: choco install firefoxpwa   # or: winget install filips.FirefoxPWA";
+    case "linux":
+      if (execSyncOk("which apt-get")) return "apt install firefoxpwa        # Debian/Ubuntu";
+      if (execSyncOk("which dnf")) return "dnf install firefoxpwa        # Fedora/RHEL";
+      if (execSyncOk("which pacman")) return "pacman -S firefoxpwa          # Arch";
+      return "See: https://pwasforfirefox.filips.si/installation/";
+    default:
+      return "See: https://pwasforfirefox.filips.si/installation/";
+  }
+}
+function probeInstalledApp(manifestUrl) {
+  try {
+    const out = execSync("firefoxpwa profile list", { encoding: "utf-8", windowsHide: true });
+    const lines = out.split("\n");
+    let currentProfile = "";
+    for (const line of lines) {
+      const idMatch = line.match(/^ID:\s+(\S+)/);
+      if (idMatch) {
+        currentProfile = idMatch[1];
+        continue;
+      }
+      const appMatch = line.match(/-\s+\S+:\s+(\S+)\s+\((\S+)\)/);
+      if (appMatch && currentProfile) {
+        if (appMatch[1] === manifestUrl) {
+          return { appId: appMatch[2], profileId: currentProfile };
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function isServerReachable(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/manifest.webmanifest`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function printPwaHelp() {
+  console.log(
+    cliT({
+      en: `
+PWA Commands (via Firefox PWAsForFirefox):
+
+  openfox pwa           Start the PWA install walkthrough
+  openfox pwa install   Install OpenFox as a desktop PWA
+  openfox pwa uninstall Remove the OpenFox PWA from your system
+  openfox pwa launch    Launch the OpenFox PWA
+  openfox pwa update    Re-register the PWA (use after upgrading OpenFox)
+  openfox pwa status    Check if the PWA is installed
+
+Requirements:
+  Install PWAsForFirefox first: https://pwasforfirefox.filips.si/installation/
+`,
+      fr: `
+Commandes PWA (via Firefox PWAsForFirefox) :
+
+  openfox pwa           D\xE9marrer l\u2019assistant d\u2019installation PWA
+  openfox pwa install   Installer OpenFox comme PWA de bureau
+  openfox pwa uninstall Supprimer la PWA OpenFox de votre syst\xE8me
+  openfox pwa launch    Lancer la PWA OpenFox
+  openfox pwa update    R\xE9enregistrer la PWA (apr\xE8s une mise \xE0 jour d\u2019OpenFox)
+  openfox pwa status    V\xE9rifier si la PWA est install\xE9e
+
+Pr\xE9requis :
+  Installez d\u2019abord PWAsForFirefox : https://pwasforfirefox.filips.si/installation/
+`
+    })
+  );
+}
+async function runPwaCommand(mode, subcommand) {
+  switch (subcommand) {
+    case "install":
+    case void 0:
+      await pwaInstall(mode);
+      break;
+    case "uninstall":
+      await pwaUninstall(mode);
+      break;
+    case "launch":
+      await pwaLaunch(mode);
+      break;
+    case "update":
+      await pwaUpdate(mode);
+      break;
+    case "status":
+      await pwaStatus(mode);
+      break;
+    default:
+      printPwaHelp();
+  }
+}
+async function pwaInstall(mode) {
+  const manifestUrl = getManifestUrl(mode);
+  if (!isFirefoxPwaAvailable()) {
+    const hint = getFirefoxPwaInstallHint();
+    log.error(
+      cliT({
+        en: "firefoxpwa is not installed or not on your PATH.",
+        fr: "firefoxpwa n\u2019est pas install\xE9 ou absent de votre PATH."
+      })
+    );
+    console.log(
+      cliT({
+        en: `
+Install it first:
+
+  ${hint}
+
+See: https://pwasforfirefox.filips.si/installation/`,
+        fr: `
+Installez-le d\u2019abord :
+
+  ${hint}
+
+Voir : https://pwasforfirefox.filips.si/installation/`
+      })
+    );
+    process.exit(1);
+  }
+  if (!isRuntimeInstalled()) {
+    const install = await confirm({
+      message: cliT({
+        en: "Firefox PWA runtime is not installed. Install it now?",
+        fr: "Le runtime Firefox PWA n\u2019est pas install\xE9. L\u2019installer maintenant ?"
+      }),
+      initialValue: true
+    });
+    if (isCancel(install)) {
+      cancel();
+      process.exit(0);
+    }
+    if (install) {
+      log.info(cliT({ en: "Running: firefoxpwa runtime install", fr: "Ex\xE9cution : firefoxpwa runtime install" }));
+      try {
+        spawn("firefoxpwa", ["runtime", "install"], { stdio: "inherit", windowsHide: true });
+      } catch {
+        log.error(cliT({ en: "Failed to install runtime.", fr: "\xC9chec de l\u2019installation du runtime." }));
+        process.exit(1);
+      }
+    } else {
+      log.info(
+        cliT({
+          en: "Skipping runtime install. The PWA cannot be used until the runtime is installed.",
+          fr: "Installation du runtime ignor\xE9e. La PWA ne pourra pas \xEAtre utilis\xE9e tant que le runtime n\u2019est pas install\xE9."
+        })
+      );
+      process.exit(0);
+    }
+  }
+  const port = mode === "development" ? 10469 : 10369;
+  if (!await isServerReachable(port)) {
+    log.error(
+      cliT({
+        en: `OpenFox server is not reachable on port ${port}.`,
+        fr: `Le serveur OpenFox est injoignable sur le port ${port}.`
+      })
+    );
+    console.log(
+      cliT({ en: `
+Start OpenFox first:
+
+  openfox
+`, fr: `
+D\xE9marrez d\u2019abord OpenFox :
+
+  openfox
+` })
+    );
+    process.exit(1);
+  }
+  const existing = await loadPwaConfig(mode);
+  if (existing) {
+    const installed = probeInstalledApp(manifestUrl);
+    if (installed) {
+      log.info(cliT({ en: "OpenFox PWA is already installed.", fr: "La PWA OpenFox est d\xE9j\xE0 install\xE9e." }));
+      console.log(cliT({ en: `  App ID:    ${installed.appId}`, fr: `  ID de l\u2019app :    ${installed.appId}` }));
+      console.log(cliT({ en: `  Profile:   ${installed.profileId}`, fr: `  Profil :   ${installed.profileId}` }));
+      console.log(cliT({ en: `  URL:       ${manifestUrl}`, fr: `  URL :       ${manifestUrl}` }));
+      console.log(
+        cliT({
+          en: `
+Use "openfox pwa launch" to start it, or "openfox pwa uninstall" to remove it.`,
+          fr: `
+Utilisez \xAB openfox pwa launch \xBB pour la lancer, ou \xAB openfox pwa uninstall \xBB pour la supprimer.`
+        })
+      );
+      return;
+    }
+  }
+  if (existing) {
+    await removePwaConfig(mode);
+  }
+  log.info(cliT({ en: "Installing OpenFox PWA...", fr: "Installation de la PWA OpenFox..." }));
+  let appId = "";
+  let profileId = "00000000000000000000000000";
+  try {
+    execSync(`firefoxpwa site install ${manifestUrl}`, { encoding: "utf-8", windowsHide: true });
+    const detected = probeInstalledApp(manifestUrl);
+    if (detected) {
+      appId = detected.appId;
+      profileId = detected.profileId;
+    }
+  } catch {
+    log.error(
+      cliT({
+        en: "Failed to install PWA. Ensure OpenFox is running and try again.",
+        fr: "\xC9chec de l\u2019installation de la PWA. Assurez-vous qu\u2019OpenFox tourne et r\xE9essayez."
+      })
+    );
+    process.exit(1);
+  }
+  if (!appId) {
+    log.error(
+      cliT({
+        en: "Could not detect installed app ID. The PWA may still be installed.",
+        fr: "Impossible de d\xE9tecter l\u2019ID de l\u2019application install\xE9e. La PWA est peut-\xEAtre quand m\xEAme install\xE9e."
+      })
+    );
+    console.log(cliT({ en: "Check with: firefoxpwa profile list", fr: "V\xE9rifiez avec : firefoxpwa profile list" }));
+    process.exit(1);
+  }
+  const pwaConfig = { appId, profileId, manifestUrl, installedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await savePwaConfig(mode, pwaConfig);
+  log.info(cliT({ en: "OpenFox PWA installed successfully!", fr: "PWA OpenFox install\xE9e avec succ\xE8s !" }));
+  console.log(cliT({ en: `
+  App ID:  ${appId}`, fr: `
+  ID de l\u2019app :  ${appId}` }));
+  console.log(cliT({ en: `  Profile: ${profileId}`, fr: `  Profil : ${profileId}` }));
+  console.log(cliT({ en: `
+Launch it with: openfox pwa launch`, fr: `
+Lancez-la avec : openfox pwa launch` }));
+}
+async function pwaUninstall(mode) {
+  if (!isFirefoxPwaAvailable()) {
+    log.error(
+      cliT({
+        en: "firefoxpwa is not installed or not on your PATH.",
+        fr: "firefoxpwa n\u2019est pas install\xE9 ou absent de votre PATH."
+      })
+    );
+    process.exit(1);
+  }
+  const manifestUrl = getManifestUrl(mode);
+  const existing = await loadPwaConfig(mode);
+  let appId = existing?.appId ?? "";
+  if (!appId) {
+    const detected = probeInstalledApp(manifestUrl);
+    if (detected) appId = detected.appId;
+  }
+  if (!appId) {
+    log.info(cliT({ en: "OpenFox PWA is not installed.", fr: "La PWA OpenFox n\u2019est pas install\xE9e." }));
+    return;
+  }
+  log.info(cliT({ en: "Removing OpenFox PWA...", fr: "Suppression de la PWA OpenFox..." }));
+  try {
+    execSync(`firefoxpwa site uninstall ${appId} --quiet`, { encoding: "utf-8", windowsHide: true });
+  } catch {
+    log.error(
+      cliT({
+        en: `Failed to uninstall PWA (ID: ${appId}).`,
+        fr: `\xC9chec de la d\xE9sinstallation de la PWA (ID : ${appId}).`
+      })
+    );
+    process.exit(1);
+  }
+  await removePwaConfig(mode);
+  log.info(cliT({ en: "OpenFox PWA removed from your system.", fr: "PWA OpenFox supprim\xE9e de votre syst\xE8me." }));
+  console.log(
+    cliT({
+      en: "\nNote: The Firefox PWA runtime is still installed.",
+      fr: "\nRemarque : le runtime Firefox PWA est toujours install\xE9."
+    })
+  );
+  console.log(
+    cliT({ en: "To remove it: firefoxpwa runtime uninstall", fr: "Pour le supprimer : firefoxpwa runtime uninstall" })
+  );
+}
+async function pwaLaunch(mode) {
+  if (!isFirefoxPwaAvailable()) {
+    log.error(
+      cliT({
+        en: "firefoxpwa is not installed or not on your PATH.",
+        fr: "firefoxpwa n\u2019est pas install\xE9 ou absent de votre PATH."
+      })
+    );
+    process.exit(1);
+  }
+  const manifestUrl = getManifestUrl(mode);
+  const existing = await loadPwaConfig(mode);
+  let appId = existing?.appId ?? "";
+  if (!appId) {
+    const detected = probeInstalledApp(manifestUrl);
+    if (detected) appId = detected.appId;
+  }
+  if (!appId) {
+    log.info(cliT({ en: "OpenFox PWA is not installed.", fr: "La PWA OpenFox n\u2019est pas install\xE9e." }));
+    console.log(
+      cliT({ en: "\nInstall it first: openfox pwa install", fr: "\nInstallez-la d\u2019abord : openfox pwa install" })
+    );
+    return;
+  }
+  log.info(cliT({ en: "Launching OpenFox PWA...", fr: "Lancement de la PWA OpenFox..." }));
+  spawn("firefoxpwa", ["site", "launch", appId], { stdio: "inherit", windowsHide: true });
+}
+async function pwaUpdate(mode) {
+  if (!isFirefoxPwaAvailable()) {
+    log.error(
+      cliT({
+        en: "firefoxpwa is not installed or not on your PATH.",
+        fr: "firefoxpwa n\u2019est pas install\xE9 ou absent de votre PATH."
+      })
+    );
+    process.exit(1);
+  }
+  const manifestUrl = getManifestUrl(mode);
+  const existing = await loadPwaConfig(mode);
+  let appId = existing?.appId ?? "";
+  if (!appId) {
+    const detected = probeInstalledApp(manifestUrl);
+    if (detected) appId = detected.appId;
+  }
+  if (!appId) {
+    log.info(cliT({ en: "OpenFox PWA is not installed.", fr: "La PWA OpenFox n\u2019est pas install\xE9e." }));
+    console.log(
+      cliT({ en: "\nInstall it first: openfox pwa install", fr: "\nInstallez-la d\u2019abord : openfox pwa install" })
+    );
+    return;
+  }
+  try {
+    execSync(`firefoxpwa site update ${appId}`, { encoding: "utf-8", windowsHide: true });
+  } catch {
+    log.error(cliT({ en: "Failed to update PWA metadata.", fr: "\xC9chec de la mise \xE0 jour des m\xE9tadonn\xE9es PWA." }));
+    process.exit(1);
+  }
+  log.info(cliT({ en: "OpenFox PWA metadata updated.", fr: "M\xE9tadonn\xE9es PWA OpenFox mises \xE0 jour." }));
+  console.log(
+    cliT({
+      en: `
+The manifest is re-fetched automatically on each launch.`,
+      fr: `
+Le manifeste est re-t\xE9l\xE9charg\xE9 automatiquement \xE0 chaque lancement.`
+    })
+  );
+  console.log(
+    cliT({
+      en: `Launch to pick up OpenFox changes:
+
+  openfox pwa launch`,
+      fr: `Lancez la PWA pour appliquer les changements d\u2019OpenFox :
+
+  openfox pwa launch`
+    })
+  );
+}
+async function pwaStatus(mode) {
+  if (!isFirefoxPwaAvailable()) {
+    log.error(
+      cliT({
+        en: "firefoxpwa is not installed or not on your PATH.",
+        fr: "firefoxpwa n\u2019est pas install\xE9 ou absent de votre PATH."
+      })
+    );
+    console.log(
+      cliT({
+        en: "\nInstall PWAsForFirefox: https://pwasforfirefox.filips.si/installation/",
+        fr: "\nInstallez PWAsForFirefox : https://pwasforfirefox.filips.si/installation/"
+      })
+    );
+    return;
+  }
+  if (!isRuntimeInstalled()) {
+    log.warn(cliT({ en: "Firefox PWA runtime is not installed.", fr: "Le runtime Firefox PWA n\u2019est pas install\xE9." }));
+    console.log(cliT({ en: `
+Run: firefoxpwa runtime install`, fr: `
+Ex\xE9cutez : firefoxpwa runtime install` }));
+    return;
+  }
+  const manifestUrl = getManifestUrl(mode);
+  const existing = await loadPwaConfig(mode);
+  let appId = existing?.appId ?? "";
+  if (!appId) {
+    const detected = probeInstalledApp(manifestUrl);
+    if (detected) appId = detected.appId;
+  }
+  if (!appId) {
+    log.info(cliT({ en: "OpenFox PWA is not installed.", fr: "La PWA OpenFox n\u2019est pas install\xE9e." }));
+    console.log(cliT({ en: "\nInstall it: openfox pwa install", fr: "\nInstallez-la : openfox pwa install" }));
+    return;
+  }
+  log.info(cliT({ en: "OpenFox PWA is installed.", fr: "La PWA OpenFox est install\xE9e." }));
+  console.log(cliT({ en: `
+  App ID:      ${appId}`, fr: `
+  ID de l\u2019app :      ${appId}` }));
+  console.log(
+    cliT({
+      en: `  Profile ID:  ${existing?.profileId ?? "default"}`,
+      fr: `  ID du profil :  ${existing?.profileId ?? "default"}`
+    })
+  );
+  console.log(cliT({ en: `  Manifest:    ${manifestUrl}`, fr: `  Manifeste :    ${manifestUrl}` }));
+  console.log(
+    cliT({
+      en: `  Installed:   ${existing?.installedAt ? new Date(existing.installedAt).toLocaleString() : "unknown"}`,
+      fr: `  Install\xE9e le :   ${existing?.installedAt ? new Date(existing.installedAt).toLocaleString() : "inconnu"}`
+    })
+  );
+}
+export {
+  getManifestUrl,
+  isServerReachable,
+  loadPwaConfig,
+  printPwaHelp,
+  removePwaConfig,
+  runPwaCommand,
+  savePwaConfig
+};
+//# sourceMappingURL=pwa-V5PFB4OQ.js.map

package/dist/{registry-CMSSZHDC.js → registry-BEIR7Y5G.js}

@@ -17,10 +17,10 @@ import {
   resolveDefaultAgentId,
   saveAgent,
   saveAgentToProject
-} from "./chunk-ELYHHEYL.js";
+} from "./chunk-ORCQ3EXQ.js";
 import "./chunk-OSXPQSLW.js";
 import "./chunk-DPFET73G.js";
-import "./chunk-LQKXJPKP.js";
+import "./chunk-CTWZPN7G.js";
 import "./chunk-JU757HVI.js";
 import "./chunk-K44MW7JJ.js";
 import "./chunk-CQGTEGKL.js";
@@ -45,4 +45,4 @@ export {
   saveAgent,
   saveAgentToProject
 };
-//# sourceMappingURL=registry-CMSSZHDC.js.map
+//# sourceMappingURL=registry-BEIR7Y5G.js.map

package/dist/{serve-XRVT3D7Z.js → serve-CW5C3CBZ.js}

@@ -1,63 +1,66 @@
 import {
   createServer
-} from "./chunk-OUQZZEIQ.js";
+} from "./chunk-BIZFY3QP.js";
 import "./chunk-T3S5MTMD.js";
 import "./chunk-WLJJRX22.js";
 import "./chunk-DQTN4B33.js";
 import "./chunk-IJ53Y77N.js";
-import "./chunk-A7CB4USC.js";
-import "./chunk-RRUSYVQD.js";
-import "./chunk-P5MSY7ZI.js";
-import "./chunk-GFW2HWJ6.js";
-import "./chunk-HXHPKGJE.js";
+import "./chunk-GP3CLMPQ.js";
+import "./chunk-NFEZATSN.js";
+import "./chunk-5H5NRWHA.js";
+import "./chunk-4R5GV7RW.js";
+import "./chunk-ESZQTFQP.js";
 import "./chunk-XE6UC5Z3.js";
 import "./chunk-J7GAZGZT.js";
-import "./chunk-FEIRWXLX.js";
-import "./chunk-TACWRDDC.js";
-import "./chunk-ZL4IAFF3.js";
+import {
+  serverT
+} from "./chunk-OZWHRBDY.js";
+import "./chunk-S67WIWUG.js";
+import "./chunk-UKIUQAQZ.js";
 import "./chunk-7ET46SNE.js";
 import "./chunk-LW6MMSTD.js";
-import "./chunk-MQMPIXON.js";
+import "./chunk-5UMXFLET.js";
 import "./chunk-I72ACQ6R.js";
 import "./chunk-JE7LW7Y6.js";
 import "./chunk-OAN4BXEW.js";
-import "./chunk-VXG3AFFY.js";
-import "./chunk-BKMWZTNO.js";
-import "./chunk-7JVBDBXE.js";
+import "./chunk-VHLD6PCZ.js";
+import "./chunk-DWA4IE65.js";
+import "./chunk-7QMWYNVF.js";
 import "./chunk-JURM3RPZ.js";
-import "./chunk-Y6ZGHOKM.js";
-import "./chunk-FGNJMKDV.js";
-import "./chunk-M5T4RDPJ.js";
-import "./chunk-KWAHD2JA.js";
+import "./chunk-I5ODJKYM.js";
+import "./chunk-QZOV4OVN.js";
+import "./chunk-MEEUXRFL.js";
+import "./chunk-F2MOHHXB.js";
 import {
   loadConfig
-} from "./chunk-ELYHHEYL.js";
+} from "./chunk-ORCQ3EXQ.js";
 import "./chunk-OSXPQSLW.js";
-import "./chunk-P57IBMK4.js";
+import "./chunk-AATMPL7S.js";
 import "./chunk-LCLH6ZUL.js";
-import "./chunk-MGEYAYGU.js";
-import "./chunk-5JWJEZJ3.js";
+import "./chunk-O3RCSKUH.js";
+import "./chunk-5UQ4CKOA.js";
 import "./chunk-OA2FURC3.js";
 import "./chunk-J2GP3J3X.js";
 import "./chunk-YNMP647F.js";
 import {
   VERSION
-} from "./chunk-JKGHTBEV.js";
+} from "./chunk-WY3PWHWY.js";
 import "./chunk-DPFET73G.js";
-import "./chunk-CLDCHOEA.js";
+import "./chunk-ZMK4VX7V.js";
 import "./chunk-TS5WKTFB.js";
 import "./chunk-UV6IH6HK.js";
 import "./chunk-HNCM3D7Y.js";
 import "./chunk-EUOWCVU6.js";
-import "./chunk-6EZDW4JS.js";
-import "./chunk-LQKXJPKP.js";
+import "./chunk-J3NMNYGM.js";
+import "./chunk-CTWZPN7G.js";
 import "./chunk-JU757HVI.js";
 import "./chunk-2AI7VYPN.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
 import "./chunk-7OHXF5GW.js";
-import "./chunk-HCYSGLY2.js";
+import "./chunk-HF3NDXB4.js";
+import "./chunk-24YKXKCG.js";
 import {
   getActiveProvider,
   getDefaultModel,
@@ -136,25 +139,33 @@ function displayStartupBanner(config) {
 \u{1F98A} OpenFox v${VERSION}
 `);
   if (isLocalhost) {
-    console.log(`  \u{1F310} Server: http://localhost:${port}`);
-    console.log("  \u{1F512} Access: Localhost only");
+    console.log(`  \u{1F310} ${serverT({ en: `Server: http://localhost:${port}`, fr: `Serveur : http://localhost:${port}` })}`);
+    console.log(`  \u{1F512} ${serverT({ en: "Access: Localhost only", fr: "Acc\xE8s : localhost uniquement" })}`);
   } else {
     const ips = getValidIPv4Addresses();
     if (ips.length === 0) {
-      console.log(`  \u{1F310} Server: http://0.0.0.0:${port}`);
-      console.warn("  \u26A0\uFE0F  Warning: No valid network interfaces detected");
+      console.log(`  \u{1F310} ${serverT({ en: `Server: http://0.0.0.0:${port}`, fr: `Serveur : http://0.0.0.0:${port}` })}`);
+      console.warn(
+        `  \u26A0\uFE0F  ${serverT({ en: "Warning: No valid network interfaces detected", fr: "Avertissement : aucune interface r\xE9seau valide d\xE9tect\xE9e" })}`
+      );
     } else {
-      console.log("  \u{1F310} Server:");
+      console.log(`  \u{1F310} ${serverT({ en: "Server:", fr: "Serveur :" })}`);
       for (const ip of ips) {
         console.log(`     \u2022 http://${ip}:${port}`);
       }
-      console.log("  \u{1F30D} Access: Local network");
+      console.log(`  \u{1F30D} ${serverT({ en: "Access: Local network", fr: "Acc\xE8s : r\xE9seau local" })}`);
     }
   }
   const size = getDatabaseSize(databasePath);
-  console.log(`  \u{1F4BE} Database: ${databasePath} (${size})`);
-  console.log(`  \u2699\uFE0F  Config:  ${configPath}`);
-  console.log("\n\u{1F4A1} Tip: Press Ctrl+C to stop the server\n");
+  console.log(
+    `  \u{1F4BE} ${serverT({ en: `Database: ${databasePath} (${size})`, fr: `Base de donn\xE9es : ${databasePath} (${size})` })}`
+  );
+  console.log(`  \u2699\uFE0F  ${serverT({ en: `Config:  ${configPath}`, fr: `Config :  ${configPath}` })}`);
+  console.log(
+    `
+\u{1F4A1} ${serverT({ en: "Tip: Press Ctrl+C to stop the server", fr: "Astuce : appuyez sur Ctrl+C pour arr\xEAter le serveur" })}
+`
+  );
 }
 
 // src/cli/serve.ts
@@ -229,4 +240,4 @@ async function runServe(options) {
 export {
   runServe
 };
-//# sourceMappingURL=serve-XRVT3D7Z.js.map
+//# sourceMappingURL=serve-CW5C3CBZ.js.map

package/dist/server/index.d.ts

@@ -1,7 +1,7 @@
-import { i as Diagnostic, x as Provider, M as ModelConfig, z as Session, J as SessionSummary, t as Project, G as SessionMode, H as SessionPhase, a0 as UserStepChoice, a2 as WorkflowExecution, a as Message, e as Criterion, g as CriterionStatus, r as MetadataEntry, A as Attachment, c as ContextState, D as DangerLevel$1, N as StatsIdentity, $ as ToolResult, b as Config } from '../types-BIkpxjaj.js';
+import { D as Diagnostic, N as Provider, M as ModelConfig, j as Session, i as SessionSummary, P as Project, S as SessionMode, h as SessionPhase, a1 as UserStepChoice, W as WorkflowExecution, c as Message, f as Criterion, t as CriterionStatus, g as MetadataEntry, A as Attachment, C as ContextState, v as DangerLevel$1, V as StatsIdentity, b as ToolResult, q as Config } from '../types-G10ho8PT.js';
 import { Server } from 'node:http';
-import { e as LLMClient, d as LLMToolDefinition } from '../types-CoY8Ka1C.js';
-import { a8 as QueuedMessage, a9 as ServerMessage } from '../protocol-BMUoqwYH.js';
+import { e as LLMClient, d as LLMToolDefinition } from '../types-BlQjLBui.js';
+import { a8 as QueuedMessage, a9 as ServerMessage } from '../protocol-Nr_H1_oC.js';
 
 /**
  * Model-specific configuration profiles.
@@ -427,6 +427,21 @@ declare class SessionManager {
      * @throws Error if the original session or message is not found
      */
     forkSession(originalSessionId: string, messageId: string, title?: string): Session;
+    /**
+     * Import a session from an export document into a target project.
+     *
+     * The cached layout (system prompt, tools, hash) is restored verbatim so the
+     * provider-side prefix cache stays valid, and the event history is replayed
+     * as-is. Drift between the original environment's cached layout and the
+     * target environment (system prompt, tools) is announced via injected
+     * <system-reminder> messages, followed by an import marker reminder.
+     *
+     * @param projectId - Target project (the session is created there)
+     * @param rawPayload - Exported session document (validated)
+     * @returns The imported session
+     * @throws Error for invalid payloads or unknown project
+     */
+    importSession(projectId: string, rawPayload: unknown): Promise<Session>;
     /**
      * Get a session by ID. Returns null if not found.
      * Session state is derived from EventStore.