chore: release 1.0.14

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitea/workflows/release.yml

@@ -2,7 +2,7 @@
 #
 # Метки runs-on = labels твоих act_runner (Админка Gitea → Действия → Раннеры).
 # Не используем windows-latest/macos-latest — это только GitHub-hosted.
-# По умолчанию: одна Linux-сборка Win+NSIS (Wine). macOS — когда будет раннер (см. комментарий в build-macos).
+# По умолчанию: один job на ubuntu-22.04 — Win (Wine+NSIS), Linux AppImage (x64+arm64), sync в updates без затирания других ОС.
 #
 # Один job без actions/upload-artifact: официальный upload-artifact@v4 с GitHub на Gitea
 # падает (GHESNotSupportedError). Сборка и sync-update-feed идут в одном окружении.
@@ -67,6 +67,33 @@ jobs:
 
       - run: npm ci
 
+      - run: npm run build
+
+      # Linux AppImage (x64 + arm64) до подмешивания win32-sharp в node_modules.
+      - name: Зависимости Linux AppImage и кросс-сборка arm64 на amd64
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+            qemu-user-static \
+            binfmt-support \
+            desktop-file-utils \
+            squashfs-tools
+
+      - name: electron-builder (linux AppImage x64, arm64)
+        shell: bash
+        env:
+          DND_UPDATE_FEED_URL: ${{ secrets.DND_UPDATE_FEED_URL }}
+        run: |
+          set -euo pipefail
+          if [[ -z "${DND_UPDATE_FEED_URL:-}" ]]; then
+            echo "Secret DND_UPDATE_FEED_URL is not set (URL со слэшем в конце)" >&2
+            exit 1
+          fi
+          npx electron-builder --linux AppImage --x64 --arm64 --publish never \
+            --config.publish.provider=generic \
+            --config.publish.url="${DND_UPDATE_FEED_URL}"
+
       # Не используем `npm install`: на Linux npm падает с EBADPLATFORM для win32-пакета.
       - name: sharp (@img/sharp-win32-x64) для Windows-артефакта при сборке на Linux
         shell: bash
@@ -80,8 +107,6 @@ jobs:
           test -f node_modules/@img/sharp-win32-x64/lib/sharp-win32-x64.node
           rm -rf "$tmp"
 
-      - run: npm run build
-
       - name: electron-builder (win)
         shell: bash
         env:
@@ -96,32 +121,26 @@ jobs:
             --config.publish.provider=generic \
             --config.publish.url="${DND_UPDATE_FEED_URL}"
 
-      - name: Каталог артефактов для feed (_win)
-        shell: bash
-        run: |
-          mkdir -p _win
-          shopt -s nullglob || true
-          for f in release/*; do
-            [[ -f "$f" ]] || continue
-            base=$(basename "$f")
-            case "$base" in
-              *.yml|*.yaml|*.exe|*.blockmap|*.zip) cp -v "$f" _win/ ;;
-            esac
-          done
-          ls -la _win
-
+      # Артефакты читает sync напрямую из release/ (без дублирующих _win/_linux — меньше ENOSPC).
       - name: Пустой каталог mac (пока нет сборки mac в CI)
         run: mkdir -p _mac
 
       - name: Push в публичный репозиторий updates
+        shell: bash
         env:
           DND_UPDATES_SERVER: ${{ secrets.DND_UPDATES_SERVER }}
           UPDATES_REPO: ${{ secrets.UPDATES_REPO }}
           DND_UPDATES_PUSH_TOKEN: ${{ secrets.DND_UPDATES_PUSH_TOKEN }}
-          ARTIFACT_WIN: ${{ github.workspace }}/_win
+          ARTIFACT_WIN: ${{ github.workspace }}/release
           ARTIFACT_MAC: ${{ github.workspace }}/_mac
+          ARTIFACT_LINUX: ${{ github.workspace }}/release
+          DND_FEED_TMP_ROOT: ${{ github.workspace }}/.dnd-feed-tmp
+          DND_UPDATES_SQUASH_HISTORY: '1'
           GIT_COMMIT_TAG: ${{ github.ref_name }}
-        run: node scripts/sync-update-feed.mjs
+        run: |
+          set -euo pipefail
+          mkdir -p "${{ github.workspace }}/.dnd-feed-tmp" "${{ github.workspace }}/_mac"
+          node scripts/sync-update-feed.mjs
 
   # Когда появится macOS-раннер: отдельный job build-macos, копирование eb-mac в _mac перед sync
   # или расширить шаг «Каталог артефактов»; сейчас всё в одном job `release`.

app/main/license/licenseService.ts

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 
 import { BrowserWindow, safeStorage } from 'electron';
@@ -10,7 +11,7 @@ import { isDndProductKey } from '../../shared/license/productKey';
 import { normalizeLicenseTokenInput } from '../../shared/license/tokenFormat';
 
 import { getOrCreateDeviceId } from './deviceId';
-import { licenseEncryptedPath, preferencesPath } from './paths';
+import { licenseEncryptedPath, licenseFallbackSealedPath, preferencesPath } from './paths';
 import { verifyLicenseToken } from './verifyLicenseToken';
 
 type Preferences = {
@@ -19,6 +20,8 @@ type Preferences = {
 
 type LicenseChangeListener = () => void;
 
+const FALLBACK_MAGIC = Buffer.from('DNDLF1', 'ascii');
+
 const licenseChangeListeners = new Set<LicenseChangeListener>();
 
 /** Слушатели вызываются после смены состояния лицензии (сохранённый токен, EULA, отзыв). */
@@ -75,23 +78,93 @@ export class LicenseService {
     return process.env.DND_SKIP_LICENSE === '1' || process.env.DND_SKIP_LICENSE === 'true';
   }
 
-  private readSealedToken(): string | null {
-    const p = licenseEncryptedPath(this.userData);
-    if (!fs.existsSync(p)) return null;
-    if (!safeStorage.isEncryptionAvailable()) {
-      throw new Error('safeStorage недоступен: нельзя расшифровать лицензию на этой системе');
-    }
+  /** Только для окружений без OS keychain (WSL и т.п.); слабее safeStorage — см. licensing-spec. */
+  private isInsecureFileStorageAllowed(): boolean {
+    const v = process.env.DND_LICENSE_INSECURE_FILE_STORAGE?.trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes';
+  }
+
+  private deriveFallbackKey(): Buffer {
+    return crypto
+      .createHash('sha256')
+      .update('DNDGamePlayer.license.fallback.v1\0', 'utf8')
+      .update(this.deviceId, 'utf8')
+      .digest();
+  }
+
+  private readFallbackSealedToken(): string {
+    const p = licenseFallbackSealedPath(this.userData);
     const buf = fs.readFileSync(p);
-    return safeStorage.decryptString(buf);
+    if (buf.length < FALLBACK_MAGIC.length + 12 + 16 + 1) {
+      throw new Error('license.fallback: файл повреждён или слишком короткий');
+    }
+    if (!buf.subarray(0, FALLBACK_MAGIC.length).equals(FALLBACK_MAGIC)) {
+      throw new Error('license.fallback: неверный формат');
+    }
+    const iv = buf.subarray(FALLBACK_MAGIC.length, FALLBACK_MAGIC.length + 12);
+    const tag = buf.subarray(FALLBACK_MAGIC.length + 12, FALLBACK_MAGIC.length + 12 + 16);
+    const data = buf.subarray(FALLBACK_MAGIC.length + 12 + 16);
+    const key = this.deriveFallbackKey();
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
+  }
+
+  private writeFallbackSealedToken(token: string): void {
+    const key = this.deriveFallbackKey();
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const enc = Buffer.concat([cipher.update(token, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const payload = Buffer.concat([FALLBACK_MAGIC, iv, tag, enc]);
+    fs.writeFileSync(licenseFallbackSealedPath(this.userData), payload, { mode: 0o600 });
+  }
+
+  private readSealedToken(): string | null {
+    const sealedPath = licenseEncryptedPath(this.userData);
+    const fallbackPath = licenseFallbackSealedPath(this.userData);
+
+    if (fs.existsSync(sealedPath)) {
+      if (!safeStorage.isEncryptionAvailable()) {
+        throw new Error(
+          'safeStorage недоступен: есть license.sealed, но расшифровать нельзя (часто перенос профиля или WSL без keyring). Удалите файл лицензии в настройках приложения или используйте DND_LICENSE_INSECURE_FILE_STORAGE=1 и активируйте заново.',
+        );
+      }
+      const buf = fs.readFileSync(sealedPath);
+      return safeStorage.decryptString(buf);
+    }
+
+    if (fs.existsSync(fallbackPath)) {
+      return this.readFallbackSealedToken();
+    }
+
+    return null;
   }
 
   private writeSealedToken(token: string): void {
-    if (!safeStorage.isEncryptionAvailable()) {
-      throw new Error('safeStorage недоступен: нельзя сохранить лицензию на этой системе');
-    }
     fs.mkdirSync(this.userData, { recursive: true });
-    const enc = safeStorage.encryptString(token);
-    fs.writeFileSync(licenseEncryptedPath(this.userData), enc);
+    if (safeStorage.isEncryptionAvailable()) {
+      const enc = safeStorage.encryptString(token);
+      fs.writeFileSync(licenseEncryptedPath(this.userData), enc);
+      try {
+        fs.unlinkSync(licenseFallbackSealedPath(this.userData));
+      } catch {
+        /* ok */
+      }
+      return;
+    }
+    if (this.isInsecureFileStorageAllowed()) {
+      this.writeFallbackSealedToken(token);
+      try {
+        fs.unlinkSync(licenseEncryptedPath(this.userData));
+      } catch {
+        /* ok */
+      }
+      return;
+    }
+    throw new Error(
+      'safeStorage недоступен: нельзя сохранить лицензию на этой системе (типично WSL без gnome-keyring). Запустите с переменной DND_LICENSE_INSECURE_FILE_STORAGE=1 — токен будет сохранён в зашифрованном файле (слабее OS-хранилища); либо настройте Secret Service / gnome-keyring.',
+    );
   }
 
   private clearSealedTokenFile(): void {
@@ -100,6 +173,11 @@ export class LicenseService {
     } catch {
       /* ok */
     }
+    try {
+      fs.unlinkSync(licenseFallbackSealedPath(this.userData));
+    } catch {
+      /* ok */
+    }
   }
 
   /** База для `POST /v1/activate` (и при желании совпадает с сервером отзыва). */

app/main/license/paths.ts

@@ -4,6 +4,11 @@ export function licenseEncryptedPath(userData: string): string {
   return path.join(userData, 'license.sealed');
 }
 
+/** Fallback, если нет OS keychain (WSL без gnome-keyring и т.п.); только при DND_LICENSE_INSECURE_FILE_STORAGE=1. */
+export function licenseFallbackSealedPath(userData: string): string {
+  return path.join(userData, 'license.sealed.fallback');
+}
+
 export function deviceIdPath(userData: string): string {
   return path.join(userData, 'device.id');
 }

app/main/windows/bootWindow.ts

@@ -4,6 +4,8 @@ import { app, BrowserWindow } from 'electron';
 
 import { getAppSemanticVersion } from '../versionInfo';
 
+import { loadBrandingWindowIcon } from './brandingIcon';
+
 let bootSplashRef: BrowserWindow | null = null;
 
 export function getBootSplashWindow(): BrowserWindow | null {
@@ -37,6 +39,7 @@ function bootWebPreferences(): Electron.WebPreferences {
  * Показывать после `waitForBootWindowReady`.
  */
 export function createBootWindow(): BrowserWindow {
+  const icon = loadBrandingWindowIcon();
   const win = new BrowserWindow({
     width: 440,
     height: 420,
@@ -50,8 +53,16 @@ export function createBootWindow(): BrowserWindow {
     transparent: false,
     backgroundColor: '#09090B',
     roundedCorners: true,
+    ...(icon ? { icon } : {}),
     webPreferences: bootWebPreferences(),
   });
+  if (icon) {
+    try {
+      win.setIcon(icon);
+    } catch {
+      /* ignore */
+    }
+  }
 
   bootSplashRef = win;
   win.once('closed', () => {

app/main/windows/brandingIcon.ts

@@ -0,0 +1,114 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { app, nativeImage } from 'electron';
+
+let resolved = false;
+let cached: Electron.NativeImage | undefined;
+
+/** ICO рядом с exe (вне asar): надёжно для `nativeImage` / панели задач на Windows. */
+function getPackagedBrandingIcoPath(): string | undefined {
+  if (!app.isPackaged) return undefined;
+  const p = path.join(process.resourcesPath, 'branding', 'icon.ico');
+  try {
+    if (fs.existsSync(p)) return p;
+  } catch {
+    /* ignore */
+  }
+  return undefined;
+}
+
+function brandingPngPaths(): string[] {
+  const root = app.getAppPath();
+  const relPack = path.join('dist', 'renderer', 'app-pack-icon.png');
+  const relWindow = path.join('dist', 'renderer', 'app-window-icon.png');
+  const paths: string[] = [];
+  if (app.isPackaged) {
+    const unpacked = path.join(process.resourcesPath, 'app.asar.unpacked');
+    paths.push(path.join(unpacked, relPack), path.join(unpacked, relWindow));
+  }
+  paths.push(
+    path.join(root, relPack),
+    path.join(root, relWindow),
+    path.join(root, 'build', 'icon.png'),
+    path.join(root, 'app', 'renderer', 'public', 'app-window-icon.png'),
+  );
+  return paths;
+}
+
+function tryLoadImageFile(filePath: string): Electron.NativeImage | undefined {
+  try {
+    const buf = fs.readFileSync(filePath);
+    const fromBuf = nativeImage.createFromBuffer(buf);
+    if (!fromBuf.isEmpty()) return fromBuf;
+  } catch {
+    /* ignore */
+  }
+  try {
+    const fromPath = nativeImage.createFromPath(filePath);
+    if (!fromPath.isEmpty()) return fromPath;
+  } catch {
+    /* ignore */
+  }
+  return undefined;
+}
+
+function tryLoadSvgFile(filePath: string): Electron.NativeImage | undefined {
+  try {
+    const fromPath = nativeImage.createFromPath(filePath);
+    if (!fromPath.isEmpty()) return fromPath;
+  } catch {
+    /* ignore */
+  }
+  return undefined;
+}
+
+function tryDarwinSvgPaths(): Electron.NativeImage | undefined {
+  if (process.platform !== 'darwin') return undefined;
+  const root = app.getAppPath();
+  for (const p of [
+    path.join(root, 'dist', 'renderer', 'app-logo.svg'),
+    path.join(root, 'app', 'renderer', 'public', 'app-logo.svg'),
+  ]) {
+    if (!fs.existsSync(p)) continue;
+    const img = tryLoadSvgFile(p);
+    if (img) return img;
+  }
+  return undefined;
+}
+
+/**
+ * Иконка окна / дока. Сначала ICO из `extraResources` (реальный путь на диске), затем PNG
+ * через буфер — `createFromPath` к файлам внутри `app.asar` на Windows часто даёт пустой `NativeImage`.
+ */
+export function loadBrandingWindowIcon(): Electron.NativeImage | undefined {
+  if (resolved) return cached;
+  resolved = true;
+
+  const ico = getPackagedBrandingIcoPath();
+  if (ico) {
+    const img = tryLoadImageFile(ico);
+    if (img) {
+      cached = img;
+      return cached;
+    }
+  }
+
+  for (const p of brandingPngPaths()) {
+    if (!fs.existsSync(p)) continue;
+    const img = tryLoadImageFile(p);
+    if (img) {
+      cached = img;
+      return cached;
+    }
+  }
+
+  const svgIcon = tryDarwinSvgPaths();
+  if (svgIcon) {
+    cached = svgIcon;
+    return cached;
+  }
+
+  cached = undefined;
+  return undefined;
+}

app/main/windows/createWindows.editorClose.test.ts

@@ -22,10 +22,11 @@ void test('createWindows: закрытие редактора завершает
 
 void test('createWindows: иконка окна (pack PNG, затем window PNG; SVG только вне win32)', () => {
   const src = readCreateWindows();
-  assert.ok(src.includes('resolveWindowIconPath'));
-  assert.ok(src.includes('app-pack-icon.png'));
-  assert.ok(src.includes('app-window-icon.png'));
-  assert.ok(src.includes('app-logo.svg'));
+  assert.ok(src.includes('loadBrandingWindowIcon'));
+  const branding = fs.readFileSync(path.join(here, 'brandingIcon.ts'), 'utf8');
+  assert.ok(branding.includes('app-pack-icon.png'));
+  assert.ok(branding.includes('app-window-icon.png'));
+  assert.ok(branding.includes('tryDarwinSvgPaths'));
 });
 
 void test('createWindows: пульт поверх экрана просмотра (дочернее окно)', () => {

app/main/windows/createWindows.ts

@@ -1,11 +1,11 @@
-import fs from 'node:fs';
 import path from 'node:path';
 
-import { app, BrowserWindow, nativeImage, screen } from 'electron';
+import { app, BrowserWindow, screen } from 'electron';
 
 import { ipcChannels } from '../../shared/ipc/contracts';
 
 import { getBootSplashWindow } from './bootWindow';
+import { loadBrandingWindowIcon } from './brandingIcon';
 
 type WindowKind = 'editor' | 'presentation' | 'control';
 
@@ -69,82 +69,15 @@ function getPreloadPath(): string {
   return path.join(app.getAppPath(), 'dist', 'preload', 'index.cjs');
 }
 
-/**
- * PNG для иконки окна / дока: тот же растр, что electron-builder берёт из `build/icon.png`
- * (копия в dist после сборки), затем окно 256px, затем dev-пути. SVG не используем для
- * nativeImage на Windows — иначе пустая картинка и дефолтная иконка Electron вместо exe.
- */
-function resolveBrandingPngPaths(): string[] {
-  const root = app.getAppPath();
-  return [
-    path.join(root, 'dist', 'renderer', 'app-pack-icon.png'),
-    path.join(root, 'dist', 'renderer', 'app-window-icon.png'),
-    path.join(root, 'build', 'icon.png'),
-    path.join(root, 'app', 'renderer', 'public', 'app-window-icon.png'),
-  ];
-}
-
-function resolveWindowIconPath(): string | undefined {
-  for (const p of resolveBrandingPngPaths()) {
-    try {
-      if (fs.existsSync(p)) return p;
-    } catch {
-      /* ignore */
-    }
-  }
-  const root = app.getAppPath();
-  const svgFallback = [
-    path.join(root, 'dist', 'renderer', 'app-logo.svg'),
-    path.join(root, 'app', 'renderer', 'public', 'app-logo.svg'),
-  ];
-  for (const p of svgFallback) {
-    try {
-      if (fs.existsSync(p)) return p;
-    } catch {
-      /* ignore */
-    }
-  }
-  return undefined;
-}
-
-function resolveWindowIcon(): Electron.NativeImage | undefined {
-  const tryPath = (filePath: string): Electron.NativeImage | undefined => {
-    try {
-      const img = nativeImage.createFromPath(filePath);
-      if (!img.isEmpty()) return img;
-    } catch {
-      /* ignore */
-    }
-    return undefined;
-  };
-
-  if (process.platform === 'win32' || process.platform === 'linux') {
-    for (const p of resolveBrandingPngPaths()) {
-      if (!fs.existsSync(p)) continue;
-      const img = tryPath(p);
-      if (img) return img;
-    }
-    return undefined;
-  }
-
-  const p = resolveWindowIconPath();
-  if (!p) return undefined;
-  return tryPath(p);
-}
-
-/** macOS: в Dock показываем тот же PNG, что и у упакованного приложения на Windows (иконка exe). */
+/** macOS: в Dock — тот же растр, что и у окон (ICO/PNG из brandingIcon). */
 export function applyDockIconIfNeeded(): void {
   if (process.platform !== 'darwin' || !app.dock) return;
-  for (const p of resolveBrandingPngPaths()) {
-    if (!fs.existsSync(p)) continue;
-    try {
-      const img = nativeImage.createFromPath(p);
-      if (img.isEmpty()) continue;
-      app.dock.setIcon(img);
-      return;
-    } catch {
-      /* try next */
-    }
+  const icon = loadBrandingWindowIcon();
+  if (!icon || icon.isEmpty()) return;
+  try {
+    app.dock.setIcon(icon);
+  } catch {
+    /* ignore */
   }
 }
 
@@ -180,7 +113,7 @@ function ensureWindowBecomesVisible(win: BrowserWindow): void {
 
 function createWindow(kind: WindowKind, opts?: CreateWindowOpts): BrowserWindow {
   const deferEditor = kind === 'editor' && opts?.deferVisibility === true;
-  const icon = resolveWindowIcon();
+  const icon = loadBrandingWindowIcon();
   const win = new BrowserWindow({
     width: kind === 'editor' ? 1280 : kind === 'control' ? 1200 : 1280,
     height: 800,
@@ -199,6 +132,13 @@ function createWindow(kind: WindowKind, opts?: CreateWindowOpts): BrowserWindow
       webSecurity: Boolean(process.env.VITE_DEV_SERVER_URL),
     },
   });
+  if (icon) {
+    try {
+      win.setIcon(icon);
+    } catch {
+      /* ignore */
+    }
+  }
 
   win.webContents.on('preload-error', (_event, preloadPath, error) => {
     console.error(`[preload-error] ${preloadPath}:`, error);

app/shared/package.build.test.ts

@@ -6,13 +6,16 @@ import { fileURLToPath } from 'node:url';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 
-void test('package.json: конфиг electron-builder (mac/win)', () => {
+void test('package.json: конфиг electron-builder (mac/win/linux)', () => {
   const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')) as {
     build: {
       appId: string;
       asar: boolean;
       asarUnpack: string[];
+      extraResources: { from: string; to: string }[];
       mac: { target: unknown };
+      linux: { target: unknown };
+      appImage?: { artifactName?: string };
       files: string[];
     };
   };
@@ -21,6 +24,22 @@ void test('package.json: конфиг electron-builder (mac/win)', () => {
   assert.equal(pkg.build.asar, true, 'релизный артефакт: app.asar без «голого» дерева dist в .app/.exe');
   assert.ok(Array.isArray(pkg.build.asarUnpack));
   assert.ok(pkg.build.asarUnpack.some((p) => p.includes('preload')));
+  assert.ok(Array.isArray(pkg.build.extraResources));
+  assert.ok(
+    pkg.build.extraResources.some(
+      (e: unknown) =>
+        typeof e === 'object' &&
+        e !== null &&
+        'to' in e &&
+        typeof (e as { to: unknown }).to === 'string' &&
+        (e as { to: string }).to.includes('branding'),
+    ),
+  );
   assert.ok(Array.isArray(pkg.build.mac.target));
+  assert.ok(Array.isArray(pkg.build.linux.target));
+  const linuxTargets = pkg.build.linux.target as { target: string; arch: string[] }[];
+  assert.ok(linuxTargets.some((t) => t.target === 'AppImage'));
+  assert.ok(linuxTargets.some((t) => t.arch.includes('x64') && t.arch.includes('arm64')));
+  assert.ok(pkg.build.appImage?.artifactName?.includes('${arch}'));
   assert.ok(pkg.build.files.includes('dist/**/*'));
 });

docs/GITEA_AUTO_UPDATE.md

@@ -315,7 +315,16 @@ sudo journalctl -u gitea-act-runner -f
 - В **`.gitea/workflows/release.yml`** в `runs-on:` должна совпадать **именно метка `ubuntu-22.04`** (Gitea сопоставляет её и с **`ubuntu-22.04:host`**, и с **`ubuntu-22.04:docker://...`** — см. [Labels](https://docs.gitea.com/usage/actions/act-runner#labels) в документации act_runner).
 - Если при регистрации указал только **`self-hosted`** — добавь **`ubuntu-22.04:host`** (или поменяй `runs-on` в workflow на твои метки и закоммить).
 
-Сборка **Windows (NSIS)** в CI идёт **на Linux**: нативный **`nsis`** (`makensis`) + **`wine64`** и обёртка **`wine`→`wine64`** (без **wine32**/i386 — см. `release.yml`). Отдельная **macOS**-сборка в workflow отключена, пока нет Mac-раннера (см. комментарии в `release.yml`).
+Сборка **Windows (NSIS)** и **Linux (AppImage x64 + arm64)** в CI идёт **на одном** `ubuntu-22.04`: NSIS + `wine64` для Win, `qemu-user-static` для кросс-сборки arm64 AppImage на amd64 (см. `release.yml`). **macOS** в этом job не собирается (ручная выкладка или отдельный раннер — см. `docs/MANUAL_MAC_UPDATE_UPLOAD.md`).
+
+---
+
+## Linux: AppImage и автообновление
+
+- В ветке **`updates`** рядом с Windows лежат **`latest-linux.yml`** и файлы **`*.AppImage`** (x64 и arm64). Скрипт **`scripts/sync-update-feed.mjs`** делает **merge-копирование**: файлы других ОС в репозитории **не удаляются**, обновляются только имена, пришедшие из текущего CI-прогона.
+- **Базовый дистрибутив для бинарников:** сборка на **Ubuntu 22.04 (glibc 2.35)** — совместимость с «максимумом» настольных дистрибутивов с glibc не старее целевого; **Alpine/musl** без отдельной сборки не гарантируется.
+- **Запуск AppImage:** на части систем нужен **FUSE** (например `libfuse2` для старых форматов / документация дистрибутива). Подпись пакетов в первом варианте **не** используется (как договорённость по проекту).
+- Правила **electron-updater** в приложении те же: упакованная сборка и **активная лицензия** (`installAutoUpdater.ts`).
 
 ---
 
@@ -346,19 +355,75 @@ git push origin v1.0.1
 2. В **DndGamePlayerUpdates** есть хотя бы один коммит (не пустой репо).
 3. В приватном репо заданы **все четыре** секрета из таблицы шага 2 (имена **не** начинаются с `GITEA_`).
 4. В репо с кодом есть **`.gitea/workflows/release.yml`**.
-5. Релиз: пуш тега `v*` → в Actions job **`release`** (сборка Win + push feed в одном job, без GitHub `upload-artifact`); в публичном репо появляется ветка **`updates`** с `latest.yml` и установщиками (нужен online-раннер, см. раздел про act_runner).
+5. Релиз: пуш тега `v*` → в Actions job **`release`**: сборка **Windows** + **Linux AppImage** и push feed; в публичном репо ветка **`updates`** содержит `latest.yml`, `latest-linux.yml`, установщики Windows и **`.AppImage`** для Linux (нужен online-раннер `ubuntu-22.04`, см. раздел про act_runner). Скрипт sync **не затирает** артефакты других платформ при обновлении.
 6. В приложении: обновления только **`app.isPackaged`** и при **активной лицензии** (см. `app/main/update/installAutoUpdater.ts`).
 
 ---
 
+## Если `git push` в `updates` падает: `remote end hung up` / таймаут
+
+Один коммит с **Windows + два AppImage** может быть **сотни МБ** — HTTPS-push иногда рвётся из‑за лимита буфера Git или таймаута **nginx / reverse proxy** перед Gitea.
+
+**В репозитории с кодом** скрипт `scripts/sync-update-feed.mjs` уже выставляет в клоне feed-репо:
+
+- `http.postBuffer` **2 GiB**;
+- отключение «медленной передачи» (`http.lowSpeedLimit` / `http.lowSpeedTime`);
+- до **3** повторов `git push` с паузой 20 с (переменная **`DND_GIT_PUSH_RETRIES`**, максимум 5).
+
+Если ошибка сохраняется — на **сервере** (nginx и т.п.) проверьте, например:
+
+- `client_max_body_size` — не меньше размера push (или `0` для безлимита, если политика безопасности позволяет);
+- `proxy_read_timeout` / `proxy_send_timeout` — **несколько минут** и больше для больших загрузок;
+- лимиты самого **Gitea** (`[repository.upload]`, `APP_MAX_FILE_SIZE` в зависимости от версии) — в документации вашей сборки Gitea.
+
+---
+
+## Линейная история в `UPDATES_REPO` (например DndGamePlayerUpdates)
+
+Переписывается **только** публичный репозиторий из секрета **`UPDATES_REPO`**, ветка **`updates`**. Репозиторий с исходниками игры (**DndGamePlayer**) и его теги **не меняются**.
+
+В workflow задано **`DND_UPDATES_SQUASH_HISTORY=1`**: после merge и подкладки артефактов скрипт делает **`git checkout --orphan`** и собирает историю **только текущего релиза**. Чтобы не отправлять один огромный pack (~700+ MiB) и не ловить `curl 55 Broken pipe`, загрузка идёт через временную ветку **`updates-upload-*`**: сначала small files, затем каждый большой файл отдельным push (порог **`DND_FEED_LARGE_FILE_BYTES`**, по умолчанию 64 MiB). Ветка **`updates`** передвигается на готовый финальный коммит только в конце через **`--force-with-lease`** (если ветка уже была) или обычный первый push. Пользователи не видят «полурелиз», потому что `updates` меняется только после полной загрузки.
+
+На **сервере Gitea** старые объекты коммитов остаются «висячими», пока не отработает **сборка мусора** репозитория (настройки сервера / ручной `git gc` в bare-репо). Для пользователей приложения важны только URL **`latest*.yml`** и установщиков — они не меняются по смыслу.
+
+Не запускайте **два релиза**, которые одновременно пушат feed, — возможна гонка и отказ **`--force-with-lease`**.
+
+---
+
+## Если push отклонён: `(fetch first)` / `rejected`
+
+Пока job собирает артефакты, в **`updates`** мог успеть попасть **другой** коммит (второй релиз, ручная выкладка). Скрипт `sync-update-feed.mjs` перед push (в режиме **без** squash) делает **`git fetch` + `git merge origin/updates`** (и после клона — то же в начале), плюс shallow **глубина** (`DND_UPDATES_CLONE_DEPTH`: по умолчанию **40**, при **`DND_UPDATES_SQUASH_HISTORY=1`** в скрипте по умолчанию **8**). В режиме **squash** перед финальным push merge **не** выполняется — уже смерженное дерево отправляется через временную ветку и затем публикуется force-with-lease. Не запускайте **два релиза одного и того же репо одновременно** по двум тегам — возможны конфликты merge.
+
+---
+
+## ENOSPC / «no space left on device» при sync
+
+Частая причина: **дублирование** артефактов (`release/` → `_linux`/`_win` → временный клон в **`/tmp`**) на раннере с маленьким root. Сейчас CI **не копирует** в `_win`/`_linux`: `ARTIFACT_WIN` и `ARTIFACT_LINUX` указывают на **`release/`**, а временный клон feed создаётся под **`DND_FEED_TMP_ROOT`** (в workflow — `${{ github.workspace }}/.dnd-feed-tmp`). Скрипт по возможности делает **`rename`** файлов в клон (без второй полной копии на том же диске).
+
+Если ошибка остаётся — на машине раннера нужно **освободить место** или увеличить диск / вынести workspace на больший том.
+
+Перед `git clone` скрипт проверяет **свободное место на томе**, где лежит `DND_FEED_TMP_ROOT` (оценка: артефакты × 2.5 + ~1 GiB запас, минимум ~2 GiB). Если проверка мешает (редкий ложный срабатывание), можно задать **`DND_FEED_SKIP_DISK_CHECK=1`** (лучше всё же поправить диск).
+
+Несколько **неудачных** `git fetch` подряд (обрыв TLS) могли раньше забивать диск частично распакованными pack-файлами; между попытками вызывается **`git gc --prune=now`**.
+
+---
+
+## Сбой fetch: `GnuTLS recv error` / `early EOF`
+
+Сеть или TLS к серверу Gitea. Скрипт делает **несколько повторов** `git fetch` (`DND_GIT_FETCH_RETRIES`, по умолчанию **6**), между попытками — **`git gc --prune=now`**, для clone/fetch задано **`http.version=HTTP/1.1`** (иногда стабильнее за прокси). Если ветки **`updates` на сервере ещё нет**, merge **намеренно** пропускается (первый push feed); при **любой другой** ошибке fetch job **завершится ошибкой** — не будет «тихого» продолжения с последующим `ENOSPC` на `git add`.
+
+При стабильных обрывах проверьте прокси/MTU/антивирус на раннере и лимиты прокси к Gitea.
+
+---
+
 ## Поведение приложения
 
 - Проверка только в **собранной** установке (`app.isPackaged`).
 - Только если **лицензия активна**.
 - Первый запрос примерно через **12 с** после старта; при смене лицензии — снова (не чаще **30 с**).
-- Для отладки можно задать переменную окружения **`DND_UPDATE_FEED_URL`** при запуске `.exe` — переопределит feed.
+- Для отладки можно задать переменную окружения **`DND_UPDATE_FEED_URL`** при запуске приложения (Windows / Linux / macOS) — переопределит feed.
 
-Подпись кода в CI отключена: `CSC_IDENTITY_AUTO_DISCOVERY=false`.
+Подпись кода в CI отключена: `CSC_IDENTITY_AUTO_DISCOVERY=false` (в т.ч. Linux AppImage без репозитория подписи).
 
 ---
 

docs/MANUAL_MAC_UPDATE_UPLOAD.md

@@ -0,0 +1,159 @@
+# Ручная выкладка macOS-обновлений в публичный feed
+
+Инструкция для случая, когда **сборка делается на вашем Mac вручную**, а файлы для `electron-updater` нужно **вручную** положить в публичный репозиторий обновлений.
+
+Общая схема проекта: приватный репозиторий с кодом, публичный **`DndGamePlayerUpdates`**, ветка **`updates`**, URL feed как в `package.json`:
+
+`https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/`
+
+---
+
+## 1. Что собрать на Mac
+
+В каталоге проекта `dnd_player`:
+
+```bash
+cd /путь/к/dnd_player
+npm ci
+npm run build
+```
+
+Сборка установщиков только под macOS (без публикации в сеть, только файлы в `release/`):
+
+```bash
+npx electron-builder --mac --publish never \
+  --config.publish.provider=generic \
+  --config.publish.url="https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/"
+```
+
+**Важно:** значение `--config.publish.url=...` должно совпадать с `package.json` → `build.publish.url` (**со слэшем в конце**). Так внутри приложения и в `latest-mac.yml` будет корректный базовый URL для скачивания.
+
+После сборки откройте папку **`release/`** в корне проекта. Там должны быть, среди прочего:
+
+- **`latest-mac.yml`** — обязателен для `electron-updater` на Mac;
+- **`.dmg`** и/или **`.zip`** — то, на что ссылается `latest-mac.yml`;
+- при необходимости **`.blockmap`** (если electron-builder их создал) — заливайте с теми же именами, что указаны в `latest-mac.yml`.
+
+Имена файлов зависят от версии и архитектур (в конфиге dmg и zip для **x64** и **arm64**). На Apple Silicon без дополнительных шагов часто получается только **arm64**; для отдельного Intel-сборщика нужна своя машина или параметры arch — ориентируйтесь на фактический список файлов в `release/`.
+
+---
+
+## 2. Куда заливать
+
+Файлы должны оказаться в **публичном** репозитории:
+
+| Параметр     | Значение                                                                  |
+| ------------ | ------------------------------------------------------------------------- |
+| Репозиторий  | `ifontosh/DndGamePlayerUpdates` (подставьте свой owner/repo, если другой) |
+| Ветка        | `updates`                                                                 |
+| Расположение | **корень ветки** (не подпапка)                                            |
+
+Проверка: в браузере должен открываться, например:
+
+`https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/latest-mac.yml`
+
+Файлы Windows (`latest.yml`, `.exe`, …), которые кладёт CI, должны **остаться** в том же корне. Вы **добавляете или обновляете** только macOS-артефакты и **`latest-mac.yml`**, не удаляя артефакты Windows (если не делаете осознанную зачистку старых версий).
+
+---
+
+## 3. Способ A — через `git` (удобно для больших dmg)
+
+### 3.1. Клон и ветка `updates`
+
+```bash
+cd ~/где-удобно
+git clone https://git.mailib.ru/ifontosh/DndGamePlayerUpdates.git
+cd DndGamePlayerUpdates
+git fetch origin
+git checkout updates
+```
+
+Если ветки `updates` ещё нет:
+
+```bash
+git checkout main
+git pull
+git checkout -b updates
+git push -u origin updates
+```
+
+Дальше для каждой выкладки работайте в ветке **`updates`**.
+
+### 3.2. Актуализировать локальную копию
+
+```bash
+git checkout updates
+git pull origin updates
+```
+
+### 3.3. Скопировать файлы из `release/` в корень клона
+
+```bash
+cp /путь/к/dnd_player/release/latest-mac.yml .
+cp /путь/к/dnd_player/release/*.dmg .
+cp /путь/к/dnd_player/release/*.zip .
+# blockmap, если есть:
+cp /путь/к/dnd_player/release/*.blockmap . 2>/dev/null || true
+```
+
+Проверка, что Windows-файлы на месте:
+
+```bash
+ls -la
+```
+
+### 3.4. Коммит и push
+
+```bash
+git add latest-mac.yml *.dmg *.zip
+git add *.blockmap 2>/dev/null || true
+git status
+git commit -m "mac: DNDGamePlayer vX.Y.Z (ручная выкладка)"
+git push origin updates
+```
+
+Для HTTPS обычно используют **персональный токен (PAT)** Gitea вместо пароля, либо настроенный **SSH** (`git@git.mailib.ru:ifontosh/DndGamePlayerUpdates.git`).
+
+### 3.5. Проверка
+
+- Откройте `latest-mac.yml` по raw-URL (см. выше).
+- Откройте в браузере прямую ссылку на один из `.dmg` из этого YAML — не должно быть 404.
+
+---
+
+## 4. Способ B — через веб-интерфейс Gitea
+
+Подходит для редких правок; для больших **dmg** удобнее git.
+
+1. Репозиторий `DndGamePlayerUpdates` → ветка **`updates`**.
+2. Загрузить или изменить **`latest-mac.yml`** и бинарники (**имена как в `release/`**).
+3. Не удалять при этом файлы Windows в корне, если они нужны для PC-обновлений.
+
+---
+
+## 5. Версии и Windows
+
+- В **`latest-mac.yml`** и в именах файлов должна быть та **версия приложения**, которую вы отдаёте пользователям Mac (как в `package.json` на момент сборки).
+- **`latest.yml`** (Windows) и **`latest-mac.yml`** (Mac) — разные файлы; версии на платформах могут совпадать или нет. Каждая ОС читает свой YAML.
+
+---
+
+## 6. Подпись кода (кратко)
+
+Без **Developer ID** и при необходимости **нотаризации** macOS может ограничивать запуск после скачивания. На процедуру «залить файлы в репо» это не влияет, но влияет на UX после автообновления. Для продакшена имеет смысл позже настроить `CSC_LINK`, `CSC_KEY_PASSWORD` и нотаризацию по [документации electron-builder](https://www.electron.build/).
+
+---
+
+## 7. Чеклист
+
+1. Локально собрали Mac с `--publish never` и верным `publish.url`.
+2. В `release/` есть **`latest-mac.yml`** и все объекты, на которые он ссылается.
+3. В ветке **`updates`** в корне репозитория обновили/добавили эти файлы, не снеся Windows-артефакты без необходимости.
+4. Проверили raw-URL **`latest-mac.yml`** и ссылку на dmg.
+5. В **упакованном** приложении с **активной лицензией** сработает существующий `electron-updater` (задержка первой проверки и cooldown — см. `app/main/update/installAutoUpdater.ts`).
+
+---
+
+## Связанные документы
+
+- Общая схема Gitea, секреты, раннер: [GITEA_AUTO_UPDATE.md](./GITEA_AUTO_UPDATE.md).

docs/licensing-spec.md

@@ -20,6 +20,18 @@
 
 Токен не хранится открытым текстом в JSON userData: используется **Electron `safeStorage`** (на macOS — связка с Keychain, на Windows — DPAPI). Идентификатор устройства — отдельный файл `device.id` (не секрет). Принятие EULA — `preferences.json` (версия текста).
 
+### Linux / WSL без keyring
+
+На Linux `safeStorage` обычно требует **Secret Service** (например `gnome-keyring` + D-Bus). В **WSL** без keyring `safeStorage.isEncryptionAvailable()` часто **false**, и сохранить токен нельзя.
+
+Явный обход (только если осознанно нужен запуск без OS-хранилища): переменная окружения **`DND_LICENSE_INSECURE_FILE_STORAGE=1`**. Тогда токен пишется в файл **`license.sealed.fallback`** (AES-256-GCM, ключ от `deviceId` + константа приложения). Это **слабее**, чем связка с ОС: при копировании `userData` + знании формата теоретически проще атаковать офлайн. Для обычного десктопа Linux с рабочим сеансом переменную не задавайте.
+
+Пример запуска AppImage:
+
+```bash
+DND_LICENSE_INSECURE_FILE_STORAGE=1 ./DNDGamePlayer-1.0.12-x64.AppImage --no-sandbox --appimage-extract-and-run
+```
+
 ## Юридическое (D9)
 
 Текст EULA в приложении (`app/renderer/legal/eulaRu.ts`) и формулировки про активацию/отзыв/устройства. Перед первым вводом ключа пользователь принимает EULA (версия `EULA_CURRENT_VERSION` в `app/shared/license/eulaVersion.ts`).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "DndGamePlayer",
-  "version": "1.0.3",
+  "version": "1.0.14",
   "description": "DNDGamePlayer — редактор и проигрыватель игр",
   "main": "dist/main/index.cjs",
   "scripts": {
@@ -18,7 +18,8 @@
     "pack": "npm run build && node scripts/release-win-prep.mjs && electron-builder",
     "pack:dir": "npm run build && node scripts/release-win-prep.mjs && electron-builder --dir",
     "pack:mac": "npm run build && electron-builder --mac",
-    "pack:win": "npm run build && node scripts/release-win-prep.mjs && electron-builder --win"
+    "pack:win": "npm run build && node scripts/release-win-prep.mjs && electron-builder --win",
+    "pack:linux": "npm run build && electron-builder --linux"
   },
   "keywords": [],
   "author": "",
@@ -60,6 +61,7 @@
     "javascript-obfuscator": "^4.2.2",
     "patch-package": "^8.0.1",
     "prettier": "^3.8.3",
+    "to-ico": "^1.1.2",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.2",
@@ -75,6 +77,12 @@
       "output": "release",
       "buildResources": "build"
     },
+    "extraResources": [
+      {
+        "from": "build/icon.ico",
+        "to": "branding/icon.ico"
+      }
+    ],
     "files": [
       "dist/**/*",
       "package.json"
@@ -82,6 +90,8 @@
     "asar": true,
     "asarUnpack": [
       "dist/preload/**",
+      "dist/renderer/app-pack-icon.png",
+      "dist/renderer/app-window-icon.png",
       "node_modules/sharp/**",
       "node_modules/@img/**",
       "node_modules/ffmpeg-static/**"
@@ -121,8 +131,26 @@
           ]
         }
       ],
+      "icon": "build/icon.ico"
+    },
+    "linux": {
+      "target": [
+        {
+          "target": "AppImage",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "category": "Game",
+      "maintainer": "DNDGamePlayer",
+      "synopsis": "DNDGamePlayer — редактор и проигрыватель игр",
       "icon": "build/icon.png"
     },
+    "appImage": {
+      "artifactName": "${productName}-${version}-${arch}.${ext}"
+    },
     "nsis": {
       "oneClick": false,
       "allowToChangeInstallationDirectory": true,

scripts/gen-window-icon.mjs

@@ -1,5 +1,6 @@
 /**
  * Растеризует app-logo.svg в app-window-icon.png для nativeImage (Windows).
+ * Пишет build/icon.png (macOS / fallback) и build/icon.ico — для exe/NSIS и «Программы и компоненты».
  * Запуск: node scripts/gen-window-icon.mjs
  */
 import fs from 'node:fs';
@@ -7,6 +8,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { Resvg } from '@resvg/resvg-js';
+import toIco from 'to-ico';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const root = path.join(__dirname, '..');
@@ -29,4 +31,18 @@ const resvg512 = new Resvg(svg, {
 });
 const packOut = resvg512.render();
 fs.writeFileSync(packIconPath, packOut.asPng());
-console.log('wrote', packIconPath, packOut.width, 'x', packOut.height, '(electron-builder)');
+console.log('wrote', packIconPath, packOut.width, 'x', packOut.height, '(electron-builder mac / fallback)');
+
+function renderPngForWidth(width) {
+  const r = new Resvg(svg, {
+    fitTo: { mode: 'width', value: width },
+  });
+  return Buffer.from(r.render().asPng());
+}
+
+const icoSizes = [16, 24, 32, 48, 64, 128, 256];
+const icoPngs = icoSizes.map((w) => renderPngForWidth(w));
+const icoBuf = await toIco(icoPngs);
+const icoPath = path.join(buildDir, 'icon.ico');
+fs.writeFileSync(icoPath, icoBuf);
+console.log('wrote', icoPath, '(electron-builder win)');

scripts/sync-update-feed.mjs

@@ -1,16 +1,27 @@
 /**
- * Складывает артефакты electron-builder (win + mac) в публичный репозиторий,
+ * Складывает артефакты electron-builder (win + mac + linux) в публичный репозиторий,
  * ветка `updates`, чтобы generic URL …/raw/branch/updates/ указывал на актуальные latest*.yml и установщики.
  *
- * Переменные окружения (имена без префикса GITEA_ — в Gitea секреты GITEA_* зарезервированы):
+ * Копирование **merge**: существующие файлы в ветке (другие ОС) не удаляются — обновляются только
+ * те имена, которые пришли из переданных каталогов артефактов.
+ *
+ * Переменные окружения:
  *   DND_UPDATES_SERVER       — https://git.example.com (без слэша в конце)
- *   UPDATES_REPO             — owner/repo (публичный репозиторий «только релизы»)
+ *   UPDATES_REPO             — owner/repo (публичный репозиторий)
  *   DND_UPDATES_PUSH_TOKEN   — PAT с правом push в UPDATES_REPO
- *   ARTIFACT_WIN    — каталог с файлами сборки Windows
- *   ARTIFACT_MAC    — каталог с файлами сборки macOS
+ *   ARTIFACT_WIN    — каталог с файлами Windows (можно пустой / отсутствует — пропуск)
+ *   ARTIFACT_MAC    — каталог с файлами macOS
+ *   ARTIFACT_LINUX  — каталог с файлами Linux (AppImage и т.д.)
  *   GIT_COMMIT_TAG  — опционально, для сообщения коммита
+ *   DND_GIT_PUSH_RETRIES — опционально, число попыток git push (1–5, по умолчанию 3)
+ *   DND_UPDATES_CLONE_DEPTH — опционально, глубина shallow clone (2–200, по умолчанию 40), чтобы merge с remote был надёжнее
+ *   DND_FEED_TMP_ROOT — каталог для временного клона feed (по умолчанию GITHUB_WORKSPACE / TMPDIR / os.tmpdir); не используйте узкий /tmp на раннере
+ *   DND_GIT_FETCH_RETRIES — число попыток git fetch (1–6, по умолчанию 6); между попытками — git gc --prune=now (освобождение после обрыва TLS/unpack)
+ *   DND_FEED_SKIP_DISK_CHECK — если "1", не проверять свободное место на томе DND_FEED_TMP_ROOT перед clone
+ *   DND_UPDATES_SQUASH_HISTORY — если "1", после каждого релиза ветка updates в UPDATES_REPO переписывается на историю только текущего релиза (orphan + временная ветка + force-with-lease)
+ *   DND_FEED_LARGE_FILE_BYTES — порог "большого" файла для дробления push в squash-режиме (по умолчанию 64 MiB)
  */
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -18,7 +29,74 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const ALLOWED_EXT = new Set(['.yml', '.yaml', '.exe', '.blockmap', '.zip', '.dmg', '.pkg']);
+const ALLOWED_EXT = new Set(['.yml', '.yaml', '.exe', '.blockmap', '.zip', '.dmg', '.pkg', '.appimage']);
+
+/** Нет ветки updates на сервере — не путать с обрывом TLS. */
+const GIT_FETCH_MISSING_UPDATES_REF_RE = /couldn't find remote ref updates\b/i;
+
+/** Одинаковые флаги для clone (до появления .git/config) и согласованы с configureGitHttp. */
+function gitHttpInlineFlags() {
+  return [
+    '-c',
+    'http.version=HTTP/1.1',
+    '-c',
+    'http.postBuffer=2147483648',
+    '-c',
+    'http.lowSpeedLimit=0',
+    '-c',
+    'http.lowSpeedTime=0',
+  ];
+}
+
+function estimateArtifactBytes(winDir, macDir, linuxDir) {
+  const dirs = [...new Set([winDir, macDir, linuxDir].filter(Boolean))];
+  let total = 0;
+  for (const fromDir of dirs) {
+    if (!fromDir || !fs.existsSync(fromDir)) continue;
+    for (const name of fs.readdirSync(fromDir)) {
+      const p = path.join(fromDir, name);
+      if (!fs.statSync(p).isFile()) continue;
+      const ext = path.extname(name).toLowerCase();
+      if (!ALLOWED_EXT.has(ext)) continue;
+      total += fs.statSync(p).size;
+    }
+  }
+  return total;
+}
+
+/** Свободные байты на томе, где лежит tmpRoot; при ошибке — «достаточно». */
+function freeBytesOnVolume(tmpRoot) {
+  try {
+    const s = fs.statfsSync(tmpRoot);
+    const bavail = typeof s.bavail === 'bigint' ? Number(s.bavail) : s.bavail;
+    const bsize = typeof s.bsize === 'bigint' ? Number(s.bsize) : s.bsize;
+    if (!Number.isFinite(bavail) || !Number.isFinite(bsize)) return Number.MAX_SAFE_INTEGER;
+    return bavail * bsize;
+  } catch {
+    return Number.MAX_SAFE_INTEGER;
+  }
+}
+
+function assertFeedDiskHeadroom(tmpRoot, artifactBytes) {
+  if (process.env.DND_FEED_SKIP_DISK_CHECK?.trim() === '1') return;
+  const avail = freeBytesOnVolume(tmpRoot);
+  const minBytes = Math.max(2_000_000_000, Math.round(artifactBytes * 2.5) + 1_000_000_000);
+  if (avail < minBytes) {
+    throw new Error(
+      `[sync-update-feed] мало места на томе «${tmpRoot}»: свободно ~${(avail / 1e9).toFixed(2)} GiB, ` +
+        `нужно примерно ≥ ${(minBytes / 1e9).toFixed(2)} GiB (артефакты ~${(artifactBytes / 1e9).toFixed(2)} GiB + shallow clone/pack + git add). ` +
+        `Освободите диск на раннере, увеличьте том или задайте DND_FEED_TMP_ROOT на другой диск. Либо DND_FEED_SKIP_DISK_CHECK=1 (не рекомендуется).`,
+    );
+  }
+}
+
+function tryGitGcPrune(work) {
+  try {
+    execFileSync('git', ['gc', '--prune=now'], { cwd: work, stdio: 'ignore' });
+  } catch {
+    /* после оборванного fetch часть pack/tmp остаётся — gc освобождает; игнорируем сбой gc */
+  }
+}
 
 function mustEnv(name) {
   const v = process.env[name]?.trim();
@@ -26,9 +104,41 @@ function mustEnv(name) {
   return v;
 }
 
-function copyFlatReleaseFiles(fromDir, toDir) {
-  if (!fs.existsSync(fromDir)) {
-    console.warn(`[sync-update-feed] skip missing dir: ${fromDir}`);
+function optionalDir(name) {
+  const v = process.env[name]?.trim();
+  return v && v.length > 0 ? v : '';
+}
+
+/** Куда класть временный клон: workspace раннера предпочтительнее, чем /tmp (место под AppImage). */
+function feedTempRoot() {
+  const a =
+    process.env.DND_FEED_TMP_ROOT?.trim() ||
+    process.env.GITHUB_WORKSPACE?.trim() ||
+    process.env.GITEA_WORKSPACE?.trim() ||
+    process.env.TMPDIR?.trim() ||
+    os.tmpdir();
+  return a;
+}
+
+/** Перенос (rename) без дублирования байтов на одном томе; иначе copy + unlink исходника (освобождение места). */
+function moveOrCopyArtifactFile(src, dest) {
+  if (fs.existsSync(dest)) {
+    fs.unlinkSync(dest);
+  }
+  try {
+    fs.renameSync(src, dest);
+    return;
+  } catch (e) {
+    const code = /** @type {NodeJS.ErrnoException} */ (e).code;
+    if (code !== 'EXDEV' && code !== 'EINVAL') throw e;
+  }
+  fs.copyFileSync(src, dest);
+  fs.unlinkSync(src);
+}
+
+function moveOrCopyFlatReleaseFiles(fromDir, toDir) {
+  if (!fromDir || !fs.existsSync(fromDir)) {
+    console.warn(`[sync-update-feed] skip missing dir: ${fromDir || '(empty)'}`);
     return 0;
   }
   let n = 0;
@@ -37,7 +147,7 @@ function copyFlatReleaseFiles(fromDir, toDir) {
     if (!fs.statSync(src).isFile()) continue;
     const ext = path.extname(name).toLowerCase();
     if (!ALLOWED_EXT.has(ext)) continue;
-    fs.copyFileSync(src, path.join(toDir, name));
+    moveOrCopyArtifactFile(src, path.join(toDir, name));
     n += 1;
   }
   return n;
@@ -47,56 +157,291 @@ function runGit(args, cwd) {
   execFileSync('git', args, { cwd, stdio: 'inherit' });
 }
 
-function emptyWorkingTreeExceptGit(cwd) {
-  for (const ent of fs.readdirSync(cwd)) {
-    if (ent === '.git') continue;
-    fs.rmSync(path.join(cwd, ent), { recursive: true, force: true });
+/** Большие AppImage + exe в одном push: без этого Git по умолчанию может оборвать HTTPS (postBuffer / stall). */
+function configureGitHttpForLargePush(cwd) {
+  // 2 GiB — достаточно для пачки артефактов; на старых Git при необходимости поднять на сервере лимиты nginx/Gitea.
+  runGit(['config', 'http.version', 'HTTP/1.1'], cwd);
+  runGit(['config', 'http.postBuffer', '2147483648'], cwd);
+  runGit(['config', 'http.lowSpeedLimit', '0'], cwd);
+  runGit(['config', 'http.lowSpeedTime', '0'], cwd);
+}
+
+function sleepSyncSeconds(seconds) {
+  try {
+    execFileSync('sleep', [String(seconds)], { stdio: 'ignore' });
+  } catch {
+    const end = Date.now() + seconds * 1000;
+    while (Date.now() < end) {
+      /* fallback без утилиты sleep */
+    }
   }
 }
 
+function feedSquashSingleCommitEnabled() {
+  return process.env.DND_UPDATES_SQUASH_HISTORY?.trim() === '1';
+}
+
+function hadOriginUpdatesRemoteRef(work) {
+  try {
+    execFileSync('git', ['show-ref', '--verify', '--quiet', 'refs/remotes/origin/updates'], {
+      cwd: work,
+      stdio: 'ignore',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sanitizeRefPart(s) {
+  return s
+    .replace(/[^0-9A-Za-z._-]+/gu, '-')
+    .replace(/^-+|-+$/gu, '')
+    .slice(0, 80);
+}
+
+function pushWithRetries(work, args, label) {
+  const retries = Math.max(1, Math.min(5, Number.parseInt(process.env.DND_GIT_PUSH_RETRIES || '3', 10) || 3));
+  let lastError;
+  for (let attempt = 1; attempt <= retries; attempt += 1) {
+    try {
+      console.log(`[sync-update-feed] ${label} (attempt ${attempt}/${retries})`);
+      execFileSync('git', args, { cwd: work, stdio: 'inherit' });
+      return;
+    } catch (err) {
+      lastError = err;
+      console.warn(`[sync-update-feed] ${label} failed (attempt ${attempt}/${retries})`);
+      if (attempt < retries) {
+        sleepSyncSeconds(20);
+      }
+    }
+  }
+  throw lastError;
+}
+
+function listFeedFiles(work) {
+  return fs
+    .readdirSync(work)
+    .filter((name) => name !== '.git' && fs.statSync(path.join(work, name)).isFile())
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function gitAddFiles(work, files) {
+  if (files.length === 0) return;
+  runGit(['add', '--', ...files], work);
+}
+
+function commitStagedIfAny(work, message) {
+  try {
+    execFileSync('git', ['diff', '--cached', '--quiet'], { cwd: work, stdio: 'ignore' });
+    return false;
+  } catch {
+    runGit(['commit', '-m', message], work);
+    return true;
+  }
+}
+
+/**
+ * История старых релизов удаляется, но загрузка идёт маленькими pack'ами:
+ * временная ветка получает small files + каждый большой файл отдельным push,
+ * а `updates` передвигается на готовый коммит только в конце.
+ */
+function publishSquashedUpdatesBranchStreamed(work, message, tag) {
+  const tempBranch = `updates-upload-${sanitizeRefPart(tag || 'ci')}-${String(Date.now())}`;
+  const files = listFeedFiles(work);
+  const largeFileBytes = Math.max(
+    8_000_000,
+    Math.min(
+      256_000_000,
+      Number.parseInt(process.env.DND_FEED_LARGE_FILE_BYTES || '64000000', 10) || 64_000_000,
+    ),
+  );
+  const smallFiles = [];
+  const largeFiles = [];
+  for (const file of files) {
+    const size = fs.statSync(path.join(work, file)).size;
+    if (size >= largeFileBytes) {
+      largeFiles.push(file);
+    } else {
+      smallFiles.push(file);
+    }
+  }
+
+  console.warn(
+    `[sync-update-feed] DND_UPDATES_SQUASH_HISTORY=1: переписываем только UPDATES_REPO/updates; ` +
+      `push дробится через временную ветку ${tempBranch} (${smallFiles.length} small, ${largeFiles.length} large)`,
+  );
+
+  runGit(['checkout', '--orphan', 'dnd-feed-upload-tmp'], work);
+  execFileSync('git', ['rm', '-r', '--cached', '--ignore-unmatch', '.'], { cwd: work, stdio: 'inherit' });
+
+  let pushedTemp = false;
+  gitAddFiles(work, smallFiles);
+  if (commitStagedIfAny(work, `${message} (metadata)`)) {
+    pushWithRetries(
+      work,
+      ['push', '--force', '-u', 'origin', `HEAD:refs/heads/${tempBranch}`],
+      `push temp feed branch ${tempBranch}`,
+    );
+    pushedTemp = true;
+  }
+
+  for (const file of largeFiles) {
+    gitAddFiles(work, [file]);
+    if (commitStagedIfAny(work, `${message}: ${file}`)) {
+      pushWithRetries(
+        work,
+        ['push', ...(pushedTemp ? [] : ['--force', '-u']), 'origin', `HEAD:refs/heads/${tempBranch}`],
+        `push temp feed object ${file}`,
+      );
+      pushedTemp = true;
+    }
+  }
+
+  if (!pushedTemp) {
+    throw new Error('[sync-update-feed] no feed files staged for streamed squash push');
+  }
+
+  const updateArgs = hadOriginUpdatesRemoteRef(work)
+    ? ['push', '--force-with-lease', '-u', 'origin', 'HEAD:updates']
+    : ['push', '-u', 'origin', 'HEAD:updates'];
+  pushWithRetries(work, updateArgs, 'publish complete feed branch updates');
+
+  try {
+    execFileSync('git', ['push', 'origin', `:refs/heads/${tempBranch}`], { cwd: work, stdio: 'inherit' });
+  } catch {
+    console.warn(`[sync-update-feed] temp branch cleanup failed: ${tempBranch}`);
+  }
+}
+
+function mergeOriginUpdates(work) {
+  const fetchRetries = Math.max(
+    1,
+    Math.min(8, Number.parseInt(process.env.DND_GIT_FETCH_RETRIES || '6', 10) || 6),
+  );
+  let fetchOk = false;
+  /** @type {Error | undefined} */
+  let lastFetchErr;
+  for (let i = 0; i < fetchRetries; i += 1) {
+    const r = spawnSync('git', ['fetch', 'origin', 'updates'], {
+      cwd: work,
+      encoding: 'utf8',
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    if (r.status === 0) {
+      fetchOk = true;
+      break;
+    }
+    const errText = `${r.stderr || ''}\n${r.stdout || ''}`;
+    if (GIT_FETCH_MISSING_UPDATES_REF_RE.test(errText)) {
+      console.warn('[sync-update-feed] ветки updates нет на remote — пропуск merge (первый push feed)');
+      return;
+    }
+    lastFetchErr = new Error(errText.trim() || `git fetch exited with status ${String(r.status)}`);
+    console.warn(`[sync-update-feed] git fetch failed (attempt ${i + 1}/${fetchRetries})`);
+    if (r.stderr?.trim()) {
+      console.warn(r.stderr.trim());
+    }
+    tryGitGcPrune(work);
+    if (i < fetchRetries - 1) {
+      sleepSyncSeconds(18);
+    }
+  }
+  if (!fetchOk) {
+    throw lastFetchErr ?? new Error('git fetch origin updates failed');
+  }
+  runGit(['merge', '--no-edit', 'origin/updates'], work);
+}
+
+function pushUpdatesBranch(work) {
+  const retries = Math.max(1, Math.min(5, Number.parseInt(process.env.DND_GIT_PUSH_RETRIES || '3', 10) || 3));
+  let lastError;
+  for (let attempt = 1; attempt <= retries; attempt += 1) {
+    try {
+      console.log(`[sync-update-feed] merge origin/updates before push (attempt ${attempt}/${retries})`);
+      mergeOriginUpdates(work);
+      runGit(['push', '-u', 'origin', 'updates'], work);
+      return;
+    } catch (err) {
+      lastError = err;
+      console.warn(`[sync-update-feed] merge/push failed (attempt ${attempt}/${retries})`);
+      if (attempt < retries) {
+        sleepSyncSeconds(20);
+      }
+    }
+  }
+  throw lastError;
+}
+
 function main() {
   const server = mustEnv('DND_UPDATES_SERVER').replace(/\/+$/u, '');
   const updatesRepo = mustEnv('UPDATES_REPO');
   const token = mustEnv('DND_UPDATES_PUSH_TOKEN');
-  const winDir = mustEnv('ARTIFACT_WIN');
-  const macDir = mustEnv('ARTIFACT_MAC');
+  const winDir = optionalDir('ARTIFACT_WIN');
+  const macDir = optionalDir('ARTIFACT_MAC');
+  const linuxDir = optionalDir('ARTIFACT_LINUX');
 
   const u = new URL(server);
   const host = u.host;
   const cloneUrl = `https://oauth2:${encodeURIComponent(token)}@${host}/${updatesRepo}.git`;
 
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'dnd-feed-'));
+  const tmpRoot = feedTempRoot();
+  fs.mkdirSync(tmpRoot, { recursive: true });
+  assertFeedDiskHeadroom(tmpRoot, estimateArtifactBytes(winDir, macDir, linuxDir));
+  const tmp = fs.mkdtempSync(path.join(tmpRoot, 'dnd-feed-'));
   const work = path.join(tmp, 'repo');
 
+  const squash = feedSquashSingleCommitEnabled();
+  const cloneDepth = squash
+    ? Math.max(1, Math.min(200, Number.parseInt(process.env.DND_UPDATES_CLONE_DEPTH || '8', 10) || 8))
+    : Math.max(2, Math.min(200, Number.parseInt(process.env.DND_UPDATES_CLONE_DEPTH || '40', 10) || 40));
+
+  const gh = gitHttpInlineFlags();
   try {
-    execFileSync('git', ['clone', '--depth', '1', '-b', 'updates', cloneUrl, work], { stdio: 'inherit' });
+    execFileSync('git', [...gh, 'clone', `--depth=${String(cloneDepth)}`, '-b', 'updates', cloneUrl, work], {
+      stdio: 'inherit',
+    });
   } catch {
-    execFileSync('git', ['clone', '--depth', '1', cloneUrl, work], { stdio: 'inherit' });
+    execFileSync('git', [...gh, 'clone', `--depth=${String(cloneDepth)}`, cloneUrl, work], {
+      stdio: 'inherit',
+    });
     runGit(['checkout', '-B', 'updates'], work);
   }
 
   runGit(['config', 'user.email', 'ci@gitea-actions.local'], work);
   runGit(['config', 'user.name', 'gitea-actions'], work);
+  configureGitHttpForLargePush(work);
 
-  emptyWorkingTreeExceptGit(work);
+  mergeOriginUpdates(work);
 
-  const copied = copyFlatReleaseFiles(winDir, work) + copyFlatReleaseFiles(macDir, work);
+  const artifactDirs = [...new Set([winDir, macDir, linuxDir].filter(Boolean))];
+  let copied = 0;
+  for (const d of artifactDirs) {
+    copied += moveOrCopyFlatReleaseFiles(d, work);
+  }
   if (copied === 0) {
-    throw new Error('[sync-update-feed] no release files copied (check ARTIFACT_WIN / ARTIFACT_MAC)');
+    throw new Error(
+      '[sync-update-feed] no release files copied (check ARTIFACT_WIN / ARTIFACT_MAC / ARTIFACT_LINUX)',
+    );
   }
 
   const tag = process.env.GIT_COMMIT_TAG?.trim() || 'ci';
   runGit(['add', '-A'], work);
   const st = execFileSync('git', ['status', '--porcelain'], { cwd: work }).toString().trim();
   if (st) {
-    runGit(['commit', '-m', `update feed ${tag}`], work);
-    runGit(['push', '-u', 'origin', 'updates'], work);
+    const msg = `update feed ${tag}`;
+    if (squash) {
+      publishSquashedUpdatesBranchStreamed(work, msg, tag);
+    } else {
+      runGit(['commit', '-m', msg], work);
+      pushUpdatesBranch(work);
+    }
   } else {
     console.warn('[sync-update-feed] nothing to commit (identical artifacts?)');
   }
 
   fs.rmSync(tmp, { recursive: true, force: true });
-  console.log(`[sync-update-feed] done (${String(copied)} file(s) staged)`);
+  console.log(`[sync-update-feed] done (${String(copied)} file(s) into feed repo)`);
 }
 
 main();