feat: Rename to Toju and add translation

electron/app/auto-start.ts

@@ -3,21 +3,14 @@ import AutoLaunch from 'auto-launch';
 import * as fsp from 'fs/promises';
 import * as path from 'path';
 import { readDesktopSettings } from '../desktop-settings';
+import { DESKTOP_APP_DISPLAY_NAME, patchLinuxAutostartDesktopEntryNameField } from './desktop-branding.rules';
+import { resolveLaunchPath } from './launch-path';
 
 let autoLauncher: AutoLaunch | null = null;
 let autoLaunchPath = '';
 
 const LINUX_AUTO_START_ARGUMENTS = ['--no-sandbox', '%U'];
 
-function resolveLaunchPath(): string {
-  // AppImage runs from a temporary mount; APPIMAGE points to the real file path.
-  const appImagePath = process.platform === 'linux'
-    ? String(process.env['APPIMAGE'] || '').trim()
-    : '';
-
-  return appImagePath || process.execPath;
-}
-
 function escapeDesktopEntryExecArgument(argument: string): string {
   const escapedArgument = argument.replace(/(["\\$`])/g, '\\$1');
 
@@ -35,14 +28,12 @@ function buildLinuxAutoStartExecLine(launchPath: string): string {
 }
 
 function buildLinuxAutoStartDesktopEntry(launchPath: string): string {
-  const appName = path.basename(launchPath);
-
   return [
     '[Desktop Entry]',
     'Type=Application',
     'Version=1.0',
-    `Name=${appName}`,
-    `Comment=${appName}startup script`,
+    `Name=${DESKTOP_APP_DISPLAY_NAME}`,
+    `Comment=${DESKTOP_APP_DISPLAY_NAME} startup script`,
     buildLinuxAutoStartExecLine(launchPath),
     'StartupNotify=false',
     'Terminal=false'
@@ -65,11 +56,13 @@ async function synchronizeLinuxAutoStartDesktopEntry(launchPath: string): Promis
     // Create the desktop entry if auto-launch did not leave one behind.
   }
 
-  const nextDesktopEntry = currentDesktopEntry
-    ? /^Exec=.*$/m.test(currentDesktopEntry)
-      ? currentDesktopEntry.replace(/^Exec=.*$/m, execLine)
-      : `${currentDesktopEntry.trimEnd()}\n${execLine}\n`
-    : buildLinuxAutoStartDesktopEntry(launchPath);
+  const nextDesktopEntry = patchLinuxAutostartDesktopEntryNameField(
+    currentDesktopEntry
+      ? /^Exec=.*$/m.test(currentDesktopEntry)
+        ? currentDesktopEntry.replace(/^Exec=.*$/m, execLine)
+        : `${currentDesktopEntry.trimEnd()}\n${execLine}\n`
+      : buildLinuxAutoStartDesktopEntry(launchPath)
+  );
 
   if (nextDesktopEntry === currentDesktopEntry) {
     return;
@@ -87,7 +80,7 @@ function getAutoLauncher(): AutoLaunch | null {
   if (!autoLauncher) {
     autoLaunchPath = resolveLaunchPath();
     autoLauncher = new AutoLaunch({
-      name: app.getName(),
+      name: DESKTOP_APP_DISPLAY_NAME,
       path: autoLaunchPath
     });
   }

electron/app/desktop-branding-migration.ts

@@ -0,0 +1,88 @@
+import { app } from 'electron';
+import AutoLaunch from 'auto-launch';
+import * as fsp from 'fs/promises';
+import * as path from 'path';
+
+import {
+  DESKTOP_APP_DISPLAY_NAME,
+  isLegacyLinuxAutostartEntry,
+  LEGACY_APP_REGISTRY_NAMES
+} from './desktop-branding.rules';
+import { resolveLaunchPath } from './launch-path';
+
+function getLinuxAutoStartDirectory(): string {
+  return path.join(app.getPath('home'), '.config', 'autostart');
+}
+
+export function configureDesktopBranding(): void {
+  if (!app.isPackaged) {
+    return;
+  }
+
+  app.setName(DESKTOP_APP_DISPLAY_NAME);
+
+  if (process.platform !== 'darwin') {
+    process.title = DESKTOP_APP_DISPLAY_NAME;
+  }
+}
+
+async function removeLegacyLinuxAutostartEntries(launchPath: string): Promise<void> {
+  if (process.platform !== 'linux') {
+    return;
+  }
+
+  const autostartDirectory = getLinuxAutoStartDirectory();
+  const currentLaunchBaseName = path.basename(launchPath);
+
+  let fileNames: string[] = [];
+
+  try {
+    fileNames = await fsp.readdir(autostartDirectory);
+  } catch {
+    return;
+  }
+
+  await Promise.all(fileNames.map(async (fileName) => {
+    if (!fileName.endsWith('.desktop')) {
+      return;
+    }
+
+    if (!isLegacyLinuxAutostartEntry(fileName, currentLaunchBaseName)) {
+      return;
+    }
+
+    await fsp.unlink(path.join(autostartDirectory, fileName)).catch(() => {});
+  }));
+}
+
+async function disableLegacyWindowsAutoLaunchEntries(launchPath: string): Promise<void> {
+  if (process.platform !== 'win32') {
+    return;
+  }
+
+  await Promise.all(LEGACY_APP_REGISTRY_NAMES.map(async (legacyName) => {
+    const launcher = new AutoLaunch({
+      name: legacyName,
+      path: launchPath
+    });
+
+    try {
+      if (await launcher.isEnabled()) {
+        await launcher.disable();
+      }
+    } catch {
+      // Best-effort cleanup for renamed desktop binaries.
+    }
+  }));
+}
+
+export async function migrateLegacyDesktopBranding(): Promise<void> {
+  if (!app.isPackaged) {
+    return;
+  }
+
+  const launchPath = resolveLaunchPath();
+
+  await removeLegacyLinuxAutostartEntries(launchPath);
+  await disableLegacyWindowsAutoLaunchEntries(launchPath);
+}

electron/app/desktop-branding.rules.spec.ts

@@ -0,0 +1,45 @@
+import {
+  describe,
+  expect,
+  it
+} from 'vitest';
+
+import {
+  DESKTOP_APP_DISPLAY_NAME,
+  DESKTOP_EXECUTABLE_NAME,
+  LEGACY_APP_REGISTRY_NAMES,
+  isLegacyLinuxAutostartEntry,
+  patchLinuxAutostartDesktopEntryNameField
+} from './desktop-branding.rules';
+
+describe('desktop-branding.rules', () => {
+  it('exposes the Toju desktop branding constants', () => {
+    expect(DESKTOP_APP_DISPLAY_NAME).toBe('Toju');
+    expect(DESKTOP_EXECUTABLE_NAME).toBe('toju');
+    expect(LEGACY_APP_REGISTRY_NAMES).toContain('MetoYou');
+    expect(LEGACY_APP_REGISTRY_NAMES).toContain('metoyou');
+  });
+
+  it('treats legacy linux autostart entries as removable', () => {
+    expect(isLegacyLinuxAutostartEntry('metoyou.desktop', 'toju')).toBe(true);
+    expect(isLegacyLinuxAutostartEntry('MetoYou.desktop', 'toju')).toBe(true);
+    expect(isLegacyLinuxAutostartEntry('MetoYou-1.0.0-x86_64.AppImage.desktop', 'Toju-1.1.0-x86_64.AppImage')).toBe(true);
+  });
+
+  it('keeps the current launch entry when it already uses the Toju binary', () => {
+    expect(isLegacyLinuxAutostartEntry('toju.desktop', 'toju')).toBe(false);
+    expect(isLegacyLinuxAutostartEntry('Toju-1.1.0-x86_64.AppImage.desktop', 'Toju-1.1.0-x86_64.AppImage')).toBe(false);
+  });
+
+  it('rewrites the desktop entry display name to Toju', () => {
+    const patched = patchLinuxAutostartDesktopEntryNameField([
+      '[Desktop Entry]',
+      'Type=Application',
+      'Name=metoyou',
+      'Exec=/opt/Toju/toju --no-sandbox %U'
+    ].join('\n'));
+
+    expect(patched).toContain('Name=Toju');
+    expect(patched).not.toContain('Name=metoyou');
+  });
+});

electron/app/desktop-branding.rules.ts

@@ -0,0 +1,43 @@
+export const DESKTOP_APP_DISPLAY_NAME = 'Toju';
+export const DESKTOP_EXECUTABLE_NAME = 'toju';
+
+export const LEGACY_APP_REGISTRY_NAMES = [
+  'MetoYou',
+  'MeToYou',
+  'metoyou'
+] as const;
+
+function normalizeAutostartBaseName(fileName: string): string {
+  return fileName.replace(/\.desktop$/iu, '').replace(/\.exe$/iu, '');
+}
+
+export function isLegacyLinuxAutostartEntry(
+  fileName: string,
+  currentLaunchBaseName: string
+): boolean {
+  const entryBaseName = normalizeAutostartBaseName(fileName);
+  const currentBaseName = normalizeAutostartBaseName(currentLaunchBaseName);
+
+  if (entryBaseName === currentBaseName) {
+    return false;
+  }
+
+  const normalizedEntry = entryBaseName.toLowerCase();
+
+  if (LEGACY_APP_REGISTRY_NAMES.some((legacyName) => normalizedEntry === legacyName.toLowerCase())) {
+    return true;
+  }
+
+  return /^metoyou[-.]/iu.test(entryBaseName);
+}
+
+export function patchLinuxAutostartDesktopEntryNameField(
+  desktopEntry: string,
+  displayName: string = DESKTOP_APP_DISPLAY_NAME
+): string {
+  if (/^Name=.*$/m.test(desktopEntry)) {
+    return desktopEntry.replace(/^Name=.*$/m, `Name=${displayName}`);
+  }
+
+  return desktopEntry;
+}

electron/app/flags.ts

@@ -1,7 +1,9 @@
 import { app } from 'electron';
+import { configureDesktopBranding } from './desktop-branding-migration';
 import { readDesktopSettings } from '../desktop-settings';
 
 export function configureAppFlags(): void {
+  configureDesktopBranding();
   linuxSpecificFlags();
   networkFlags();
   setupGpuEncodingFlags();

electron/app/launch-path.ts

@@ -0,0 +1,8 @@
+/** Resolves the packaged binary path used for auto-start and updater migration. */
+export function resolveLaunchPath(): string {
+  const appImagePath = process.platform === 'linux'
+    ? String(process.env['APPIMAGE'] || '').trim()
+    : '';
+
+  return appImagePath || process.execPath;
+}

electron/app/lifecycle.ts

@@ -2,6 +2,7 @@ import { app, BrowserWindow } from 'electron';
 import { cleanupLinuxScreenShareAudioRouting } from '../audio/linux-screen-share-routing';
 import { initializeDesktopUpdater, shutdownDesktopUpdater } from '../update/desktop-updater';
 import { synchronizeAutoStartSetting } from './auto-start';
+import { migrateLegacyDesktopBranding } from './desktop-branding-migration';
 import { applyLocalApiSettings, stopLocalApiServer } from '../api';
 import {
   initializeDatabase,
@@ -41,6 +42,7 @@ export function registerAppLifecycle(): void {
     setupCqrsHandlers();
     setupWindowControlHandlers();
     setupSystemHandlers();
+    await migrateLegacyDesktopBranding();
     await synchronizeAutoStartSetting();
     initializeDesktopUpdater();
     await createWindow();