opencode-deepseek-chan 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 daemon1s
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# DeepSeek-chan theme suite for OpenCode Desktop
+
+Unofficial community theme: cyber-dark and glassmorphism visual theme inspired by DeepSeek-chan for OpenCode Desktop, with an interactive terminal installer that applies and restores the theme safely — no manual code editing required.
+
+非官方社区主题：受 DeepSeek-chan 启发的赛博暗黑玻璃拟态主题，适用于 OpenCode Desktop，附带交互式终端安装器，可安全地安装与恢复主题，无需手动修改代码。
+
+![Version](https://img.shields.io/badge/version-1.0.0-4D6BFE)
+![License](https://img.shields.io/badge/license-MIT-70C0FF)
+![Platform](https://img.shields.io/badge/platform-Windows-0B1528)
+![Node](https://img.shields.io/badge/node-%3E%3D18-4D6BFE)
+![GitHub Stars](https://img.shields.io/github/stars/daemon1s/opencode-deepseek-chan)
+![GitHub Release](https://img.shields.io/github/v/release/daemon1s/opencode-deepseek-chan)
+
+## Gallery / 主题预览
+
+| Féishā | Maid whale | Midnight | Artwork |
+| --- | --- | --- | --- |
+| ![Féishā preview](./assets/previews/feisha_preview.gif) | ![Maid whale preview](./assets/previews/doncella_preview.gif) | ![Midnight preview](./assets/previews/midnight_preview.gif) | ![Artwork preview](./assets/previews/artwork_preview.png) |
+| 绯莎 | 深海女仆 | 深夜 | 插画 |
+
+## Presets / 预设
+
+The installer downloads the background assets on demand from GitHub Releases and caches them locally in `~/.opencode-deepseek-cache`, keeping the repository light.
+
+安装器按需从 GitHub Releases 下载背景资源，并缓存到本地 `~/.opencode-deepseek-cache`，保持仓库轻量。
+
+| # | Preset / 预设 | Type / 类型 | Size / 大小 |
+| --- | --- | --- | --- |
+| 1 | DeepSeek Féishā / DeepSeek 绯莎 | Video 1080p / 视频 1080p | ~6.4 MB |
+| 2 | DeepSeek Maid Whale (ZipZip) / DeepSeek 深海女仆 (ZipZip) | Video 1080p / 视频 1080p | ~11.4 MB |
+| 3 | DeepSeek Midnight / DeepSeek 深夜 | Video 1080p / 视频 1080p | ~20.2 MB |
+| 4 | DeepSeek Artwork / DeepSeek 插画 | Image 4K / 图片 4K | ~9.6 MB |
+
+## Features / 功能特性
+
+- **Professional CLI installer**: no suspicious executables (.bat or .exe); runs transparently and audibly through Node.js.
+- **DeepSeek Cyber palette**: electric blue (`#4D6BFE`), neon cyan (`#70C0FF`) and deep midnight blue (`#0B1528`).
+- **Translucent glassmorphism**: `backdrop-filter` blur on panels, chat bar and floating menus.
+- **Intact contrast and syntax**: high-specificity selectors that never touch Monaco editor syntax colors or text readability.
+- **Native CSP bypass**: the background is Base64-encoded and injected into the Electron preload cycle, avoiding local security directive blocks (`oc://renderer/index.html`).
+- **Automatic backup and safe uninstall**: creates an `app.asar.bak` backup before modifying resources, so the original app can always be restored.
+
+- **专业的 CLI 安装器**：不含可疑的可执行文件（.bat 或 .exe），全程通过 Node.js 透明、可审计地运行。
+- **DeepSeek 赛博配色**：电光蓝（`#4D6BFE`）、霓虹青（`#70C0FF`）与深午夜蓝（`#0B1528`）。
+- **半透明玻璃拟态**：面板、聊天栏和悬浮菜单均采用 `backdrop-filter` 模糊效果。
+- **保持对比度与语法高亮**：高特异性选择器不会影响 Monaco 编辑器的语法着色与文字可读性。
+- **原生绕过 CSP**：背景以 Base64 编码并注入 Electron 预加载流程，避免本地安全策略（`oc://renderer/index.html`）拦截。
+- **自动备份与安全卸载**：修改资源前自动生成 `app.asar.bak` 备份，随时可恢复原始应用。
+
+## Installation / 安装
+
+### Option 1: run directly with npx (no clone needed) / 直接使用 npx（无需克隆）
+
+```bash
+npx opencode-deepseek-chan
+```
+
+### Option 2: clone the repository / 克隆仓库
+
+```bash
+git clone https://github.com/daemon1s/opencode-deepseek-chan.git
+cd opencode-deepseek-chan
+npm install
+npm start
+```
+
+The interactive menu shows the ready-to-use presets:
+
+交互式菜单会展示预设选项：
+
+```text
+Select a background preset:
+  1) DeepSeek Féishā (1080p)
+  2) DeepSeek Maid Whale (ZipZip)
+  3) DeepSeek Midnight (1080p)
+  4) DeepSeek Artwork (4K)
+  5) Restore original OpenCode design
+  6) Exit
+```
+
+## Direct CLI usage / 命令行用法
+
+Apply a preset or restore without the interactive menu:
+
+无需交互菜单即可直接应用预设或恢复：
+
+```bash
+node bin/cli.js --preset feisha-1080p   # Video 1080p / 视频 1080p
+node bin/cli.js --preset zipzip-1080p   # Video 1080p / 视频 1080p
+node bin/cli.js --preset midnight-1080p # Video 1080p / 视频 1080p
+node bin/cli.js --preset static-4k      # Image 4K / 图片 4K
+node bin/cli.js --install /path/to/file.mp4  # Custom image or video / 自定义图片或视频
+node bin/cli.js --restore               # Restore factory state / 恢复出厂状态
+node bin/cli.js --lang zh               # Force language: en | zh | es / 指定语言
+```
+
+## Uninstall / 卸载
+
+```bash
+npm run uninstall-theme
+```
+
+Or select option **5** in the interactive menu.
+
+或直接在交互菜单中选择选项 **5**。
+
+## Project structure / 项目结构
+
+- `bin/cli.js`: interactive CLI entry point / 交互式 CLI 入口。
+- `src/engine.js`: theme CSS generation and install logic / 主题 CSS 生成与安装逻辑。
+- `src/presets.js`: preset catalog with remote URLs and integrity checks / 预设目录（远程地址与完整性校验）。
+- `src/downloader.js`: on-demand downloads with mirror fallback and local cache / 按需下载（镜像回退与本地缓存）。
+- `src/i18n.js`: multilingual strings (en / zh / es) / 多语言文案（en / zh / es）。
+- `test/`: automated tests / 自动化测试。
+
+## Credits / 致谢与许可
+
+All background assets are adapted from community artworks, used strictly for non-commercial open-source customization under the original licenses (CC BY-NC-SA 4.0). Redistributions and forks must keep this attribution intact.
+
+所有背景资源改编自社区作品，仅用于非商业的开源个性化定制，遵循原作者许可协议（CC BY-NC-SA 4.0）。再分发与分支必须保留本署名。
+
+| Preset / 预设 | Original artwork / 原作 | Source / 来源 |
+| --- | --- | --- |
+| Féishā / 绯莎 | `[绯莎]蓝色大肥鱼 deepseek娘化` by `@无菌洗手液Eva ofmaster` (Bilibili), published by `Always` | [Steam Workshop ID 3790716675](https://steamcommunity.com/sharedfiles/filedetails/?id=3790716675) |
+| Maid whale / 深海女仆 | `DeepSeek 蓝色大肥鱼 深海女仆 鲸鱼娘` by `ZipZipPipe` (Bilibili), base design by `上善无形` (Bilibili), published by `HDHKVT` | [Steam Workshop ID 3787993441](https://steamcommunity.com/sharedfiles/filedetails/?id=3787993441) |
+| Midnight / 深夜 | `[deepseek娘]深夜的大肥鱼` by `樱小路露娜` | [Steam Workshop ID 3787353838](https://steamcommunity.com/sharedfiles/filedetails/?id=3787353838) |
+| Artwork / 插画 | AI-generated by `@daemon1s`, upscaled to 4K with [Upscayl](https://upscayl.org) / 由 `@daemon1s` 使用 AI 生成，并经 Upscayl 放大至 4K | Repository original artwork / 仓库原创插画 |
+
+License terms / 许可条款:
+
+- **Non-commercial use only / 仅限非商业使用**: none of the assets may be sold, bundled for profit or included in paid commercial software.
+- **Continuous attribution / 持续署名**: any fork or redistribution must keep this credits table recognizing the original authors (`@无菌洗手液Eva ofmaster`, `ZipZipPipe`, `上善无形`, `樱小路露娜`, `Always`, `HDHKVT`).
+- **Share alike / 相同方式共享**: derivatives must be licensed under CC BY-NC-SA 4.0.

package/bin/cli.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const readline = require("readline");
+const { presets, getPresetById } = require("../src/presets");
+const { detectLocale, getLocaleStrings } = require("../src/i18n");
+const {
+  resolveAssetPath,
+  getUserCacheDirectory,
+  downloadWithFallback
+} = require("../src/downloader");
+const {
+  isOpenCodeRunning,
+  resolveOpenCodePath,
+  installTheme,
+  restoreTheme
+} = require("../src/engine");
+const { renderStaticBanner, startBannerLoop, renderProgressBar } = require("../src/banner");
+
+const colors = {
+  reset: "\x1b[0m",
+  cyan: "\x1b[36m",
+  blue: "\x1b[34m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  bold: "\x1b[1m"
+};
+
+const printBanner = () => {
+  process.stdout.write(renderStaticBanner() + "\n");
+};
+
+const parseCliArguments = () => {
+  const args = process.argv.slice(2);
+  const parsed = {
+    help: false,
+    lang: null,
+    preset: null,
+    install: null,
+    restore: false,
+    noAnimation: false
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const current = args[index];
+    if (current === "--help" || current === "-h") {
+      parsed.help = true;
+    } else if (current === "--no-animation") {
+      parsed.noAnimation = true;
+    } else if (current === "--lang" || current === "-l") {
+      parsed.lang = args[index + 1] || null;
+      index += 1;
+    } else if (current === "--preset" || current === "-p") {
+      parsed.preset = args[index + 1] || null;
+      index += 1;
+    } else if (current === "--install" || current === "-i") {
+      parsed.install = args[index + 1] || true;
+      if (args[index + 1] && !args[index + 1].startsWith("-")) {
+        index += 1;
+      }
+    } else if (
+      current === "--uninstall" ||
+      current === "-u" ||
+      current === "--restore" ||
+      current === "-r"
+    ) {
+      parsed.restore = true;
+    }
+  }
+
+  return parsed;
+};
+
+const formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1048576).toFixed(1)} MB`;
+};
+
+const obtainAssetFile = async (preset, localeStrings) => {
+  const workspaceAssetsDir = path.join(__dirname, "..", "assets");
+  const userCacheDir = getUserCacheDirectory();
+
+  const existingFile = resolveAssetPath(
+    preset,
+    workspaceAssetsDir,
+    userCacheDir
+  );
+
+  if (existingFile) {
+    return existingFile;
+  }
+
+  const destinationPath = path.join(userCacheDir, preset.filename);
+  console.log(`${colors.cyan}${localeStrings.downloading}: ${preset.filename}${colors.reset}`);
+
+  let previousRenderLength = 0;
+  const onProgress = (downloaded, total) => {
+    const ratio = total > 0 ? downloaded / total : 0;
+    const percentage = Math.round(ratio * 100);
+    const progressBar = renderProgressBar(ratio);
+    const progressText = `  ${progressBar} ${String(percentage).padStart(3)}% ${formatBytes(downloaded)} / ${formatBytes(total || preset.expectedSize)}`;
+    process.stdout.write(`\r${progressText}\x1b[K`);
+    previousRenderLength = progressText.length;
+  };
+
+  const onFallback = () => {
+    process.stdout.write("\n");
+    console.log(`${colors.yellow}${localeStrings.downloadFallback}${colors.reset}`);
+  };
+
+  await downloadWithFallback(preset, destinationPath, onProgress, onFallback);
+  process.stdout.write("\n\n");
+  return destinationPath;
+};
+
+const executeInstall = async (itemType, filePath, localeStrings) => {
+  if (isOpenCodeRunning()) {
+    console.log(`${colors.red}${localeStrings.opencodeRunning}${colors.reset}`);
+    process.exit(1);
+  }
+
+  const openCodePath = resolveOpenCodePath();
+  if (!openCodePath) {
+    console.log(`${colors.red}${localeStrings.pathNotFound}${colors.reset}`);
+    process.exit(1);
+  }
+
+  try {
+    await installTheme(itemType, filePath);
+    console.log(`${colors.green}${colors.bold}${localeStrings.installSuccess}${colors.reset}\n`);
+  } catch (error) {
+    console.log(`${colors.red}${localeStrings.error}: ${error.message}${colors.reset}`);
+    process.exit(1);
+  }
+};
+
+const executeRestore = (localeStrings) => {
+  if (isOpenCodeRunning()) {
+    console.log(`${colors.red}${localeStrings.opencodeRunning}${colors.reset}`);
+    process.exit(1);
+  }
+
+  try {
+    restoreTheme();
+    console.log(`${colors.green}${colors.bold}${localeStrings.restoreSuccess}${colors.reset}\n`);
+  } catch (error) {
+    console.log(`${colors.red}${localeStrings.error}: ${error.message}${colors.reset}`);
+    process.exit(1);
+  }
+};
+
+const promptLanguageSelection = (readlineInterface, localeStrings, cliArgs, onSelected) => {
+  const langBannerLoop = startBannerLoop({ noAnimation: cliArgs?.noAnimation });
+  console.log(`\n${colors.cyan}${localeStrings.selectLangPrompt}${colors.reset}\n`);
+  console.log(`  ${colors.bold}1)${colors.reset} English (en)`);
+  console.log(`  ${colors.bold}2)${colors.reset} 中文 (zh)`);
+  console.log(`  ${colors.bold}3)${colors.reset} Español (es)`);
+  console.log(`  ${colors.bold}4)${colors.reset} ${localeStrings.cancelOption}\n`);
+
+  readlineInterface.question(`> `, (answer) => {
+    langBannerLoop.stop();
+    const trimmed = answer.trim();
+    if (trimmed === "1") {
+      onSelected("en");
+    } else if (trimmed === "2") {
+      onSelected("zh");
+    } else if (trimmed === "3") {
+      onSelected("es");
+    } else {
+      onSelected(null);
+    }
+  });
+};
+
+const runInteractiveMenu = async (localeStrings, currentLocale = "en", cliArgs = {}) => {
+  if (process.stdout.isTTY && !cliArgs.noAnimation) {
+    process.stdout.write("\x1b[2J\x1b[1;1H");
+  }
+  printBanner();
+
+  const bannerLoop = startBannerLoop({ noAnimation: cliArgs.noAnimation });
+
+  const readlineInterface = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const changeLangOptionNumber = presets.length + 1;
+  const restoreOptionNumber = presets.length + 2;
+  const exitOptionNumber = presets.length + 3;
+
+  console.log(`${localeStrings.selectPrompt}\n`);
+  presets.forEach((preset, index) => {
+    const title = localeStrings[preset.titleKey] || preset.id;
+    console.log(`  ${colors.bold}${index + 1})${colors.reset} ${title}`);
+  });
+  console.log(`  ${colors.bold}${changeLangOptionNumber})${colors.reset} ${localeStrings.changeLangOption}`);
+  console.log(`  ${colors.bold}${restoreOptionNumber})${colors.reset} ${localeStrings.restoreOption}`);
+  console.log(`  ${colors.bold}${exitOptionNumber})${colors.reset} ${localeStrings.exitOption}\n`);
+
+  readlineInterface.question(`> `, async (answer) => {
+    bannerLoop.stop();
+    const trimmed = answer.trim();
+    const numericChoice = parseInt(trimmed, 10);
+
+    if (numericChoice >= 1 && numericChoice <= presets.length) {
+      readlineInterface.close();
+      const chosenPreset = presets[numericChoice - 1];
+      const title = localeStrings[chosenPreset.titleKey] || chosenPreset.id;
+      console.log(`\n${colors.cyan}${title}${colors.reset}\n`);
+      const assetPath = await obtainAssetFile(chosenPreset, localeStrings);
+      await executeInstall(chosenPreset.type, assetPath, localeStrings);
+    } else if (numericChoice === changeLangOptionNumber) {
+      promptLanguageSelection(readlineInterface, localeStrings, cliArgs, async (selectedLanguage) => {
+        readlineInterface.close();
+        if (selectedLanguage && selectedLanguage !== currentLocale) {
+          const updatedStrings = getLocaleStrings(selectedLanguage);
+          await runInteractiveMenu(updatedStrings, selectedLanguage, cliArgs);
+        } else {
+          await runInteractiveMenu(localeStrings, currentLocale, cliArgs);
+        }
+      });
+    } else if (numericChoice === restoreOptionNumber) {
+      readlineInterface.close();
+      executeRestore(localeStrings);
+    } else {
+      readlineInterface.close();
+      process.exit(0);
+    }
+  });
+};
+
+const main = async () => {
+  const cliArgs = parseCliArguments();
+  const currentLocale = detectLocale(cliArgs.lang);
+  const localeStrings = getLocaleStrings(currentLocale);
+
+  if (cliArgs.help) {
+    printBanner();
+    console.log("Usage:");
+    console.log("  npx opencode-deepseek-chan");
+    console.log("  npx opencode-deepseek-chan --preset <id|1-4>");
+    console.log("  npx opencode-deepseek-chan --install <file-path>");
+    console.log("  npx opencode-deepseek-chan --restore");
+    console.log("  npx opencode-deepseek-chan --lang <en|zh|es>");
+    console.log("  npx opencode-deepseek-chan --no-animation\n");
+    console.log("Available presets:");
+    presets.forEach((preset, index) => {
+      const title = localeStrings[preset.titleKey] || preset.id;
+      console.log(`  ${index + 1}) ${preset.id.padEnd(16)} ${title}`);
+    });
+    console.log("");
+    return;
+  }
+
+  if (cliArgs.restore) {
+    printBanner();
+    executeRestore(localeStrings);
+    return;
+  }
+
+  if (cliArgs.preset) {
+    printBanner();
+    const numericIndex = parseInt(cliArgs.preset, 10);
+    let chosenPreset = null;
+
+    if (!isNaN(numericIndex) && numericIndex >= 1 && numericIndex <= presets.length) {
+      chosenPreset = presets[numericIndex - 1];
+    } else {
+      chosenPreset = getPresetById(cliArgs.preset);
+    }
+
+    if (!chosenPreset) {
+      console.log(`${colors.red}${localeStrings.error}: Unknown preset ${cliArgs.preset}${colors.reset}\n`);
+      return;
+    }
+
+    const title = localeStrings[chosenPreset.titleKey] || chosenPreset.id;
+    console.log(`${colors.cyan}${title}${colors.reset}\n`);
+    const assetPath = await obtainAssetFile(chosenPreset, localeStrings);
+    await executeInstall(chosenPreset.type, assetPath, localeStrings);
+    return;
+  }
+
+  if (cliArgs.install) {
+    printBanner();
+    if (typeof cliArgs.install === "string") {
+      const cleaned = cliArgs.install.trim().replace(/^["']|["']$/g, "");
+      const extension = path.extname(cleaned).toLowerCase();
+      const isVideo = [".mp4", ".webm", ".mkv"].includes(extension);
+      await executeInstall(isVideo ? "video" : "image", cleaned, localeStrings);
+    } else {
+      const defaultPreset = presets[0];
+      const assetPath = await obtainAssetFile(defaultPreset, localeStrings);
+      await executeInstall(defaultPreset.type, assetPath, localeStrings);
+    }
+    return;
+  }
+
+  await runInteractiveMenu(localeStrings, currentLocale, cliArgs);
+};
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`\x1b[31m${error.message}\x1b[0m`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  parseCliArguments,
+  runInteractiveMenu,
+  main
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "opencode-deepseek-chan",
+  "version": "1.0.0",
+  "description": "Animated video backgrounds & cyber glassmorphism theme for OpenCode Desktop (DeepSeek-chan). 适用于 OpenCode Desktop 的 DeepSeek 赛博动态壁纸主题。",
+  "main": "bin/cli.js",
+  "bin": {
+    "opencode-deepseek-chan": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node ./bin/cli.js",
+    "test": "node --test test/*.test.js",
+    "install-theme": "node ./bin/cli.js --install",
+    "uninstall-theme": "node ./bin/cli.js --uninstall"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-desktop",
+    "theme",
+    "deepseek",
+    "dark-theme",
+    "glassmorphism",
+    "cli",
+    "deepseek-chan",
+    "video-background",
+    "electron-theme",
+    "cli-installer"
+  ],
+  "author": "daemon1s",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daemon1s/opencode-deepseek-chan.git"
+  },
+  "homepage": "https://github.com/daemon1s/opencode-deepseek-chan",
+  "bugs": {
+    "url": "https://github.com/daemon1s/opencode-deepseek-chan/issues"
+  },
+  "dependencies": {
+    "@electron/asar": "^3.2.14"
+  }
+}

package/src/banner.js

@@ -0,0 +1,131 @@
+const deepseekPalette = [
+  { r: 13, g: 37, b: 90 },
+  { r: 29, g: 99, b: 255 },
+  { r: 0, g: 210, b: 255 },
+  { r: 139, g: 233, b: 253 },
+  { r: 240, g: 248, b: 255 },
+  { r: 0, g: 210, b: 255 },
+  { r: 29, g: 99, b: 255 }
+];
+
+const bannerLines = [
+  "  ____                  ____            _                _                 ",
+  " |  _ \\  ___  ___ _ __ / ___|  ___  ___| | __        ___| |__   __ _ _ __  ",
+  " | | | |/ _ \\/ _ \\ '_ \\\\___ \\ / _ \\/ _ \\ |/ / _____ / __| '_ \\ / _` | '_ \\  ",
+  " | |_| |  __/  __/ |_) |___) |  __/  __/   < |_____| (__| | | | (_| | | | |",
+  " |____/ \\___|\\___| .__/|____/ \\___|\\___|_|\\_\\       \\___|_| |_|\\__,_|_| |_|",
+  "                 |_|                                                       "
+];
+
+const interpolateColor = (colorA, colorB, factor) => {
+  const clampedFactor = Math.max(0, Math.min(1, factor));
+  return {
+    r: Math.round(colorA.r + (colorB.r - colorA.r) * clampedFactor),
+    g: Math.round(colorA.g + (colorB.g - colorA.g) * clampedFactor),
+    b: Math.round(colorA.b + (colorB.b - colorA.b) * clampedFactor)
+  };
+};
+
+const getMultiStopColor = (palette, progress) => {
+  const normalized = ((progress % 1) + 1) % 1;
+  const segments = palette.length - 1;
+  const position = normalized * segments;
+  const index = Math.floor(position);
+  const nextIndex = Math.min(index + 1, palette.length - 1);
+  const localFactor = position - index;
+  return interpolateColor(palette[index], palette[nextIndex], localFactor);
+};
+
+const colorTextRgb = (text, r, g, b) => {
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+};
+
+const renderProgressBar = (progress, width = 24) => {
+  const clampedProgress = Math.max(0, Math.min(1, progress));
+  const filledCount = Math.round(clampedProgress * width);
+  let bar = "[";
+  for (let index = 0; index < width; index += 1) {
+    if (index < filledCount) {
+      const color = getMultiStopColor(deepseekPalette, index / width);
+      bar += `\x1b[38;2;${color.r};${color.g};${color.b}m█`;
+    } else {
+      bar += "\x1b[90m░\x1b[0m";
+    }
+  }
+  bar += "\x1b[0m]";
+  return bar;
+};
+
+const generateBannerFrame = (offset = 0) => {
+  const maxWidth = bannerLines.reduce((max, line) => Math.max(max, line.length), 0);
+  const coloredLines = bannerLines.map((line) => {
+    let coloredLine = "";
+    for (let charIndex = 0; charIndex < line.length; charIndex += 1) {
+      const char = line[charIndex];
+      if (char === " ") {
+        coloredLine += " ";
+      } else {
+        const progress = (charIndex / maxWidth + offset) % 1;
+        const color = getMultiStopColor(deepseekPalette, progress);
+        coloredLine += `\x1b[38;2;${color.r};${color.g};${color.b}m${char}`;
+      }
+    }
+    return `${coloredLine}\x1b[0m`;
+  });
+  return coloredLines.join("\n");
+};
+
+const renderStaticBanner = () => {
+  const asciiBanner = generateBannerFrame(0.15);
+  const cyanCode = "\x1b[36m";
+  const grayCode = "\x1b[90m";
+  const whiteCode = "\x1b[97m";
+  const resetCode = "\x1b[0m";
+
+  const englishTagline = `  ${cyanCode}›${resetCode} ${whiteCode}DeepSeek-chan theme suite for OpenCode Desktop${resetCode}`;
+  const chineseTagline = `  ${cyanCode}›${resetCode} ${grayCode}OpenCode Desktop 的 DeepSeek-chan (深度求索娘) 主题套件${resetCode}`;
+  const authorLine = `  ${cyanCode}›${resetCode} ${grayCode}Author: ${whiteCode}@daemon1s${resetCode} ${grayCode}(https://github.com/daemon1s)${resetCode}`;
+
+  return `${asciiBanner}\n\n${englishTagline}\n${chineseTagline}\n${authorLine}\n`;
+};
+
+const startBannerLoop = (options = {}) => {
+  const isInteractiveTty = Boolean(process.stdout.isTTY) && !options.noAnimation;
+  if (!isInteractiveTty) {
+    return {
+      stop: () => {}
+    };
+  }
+
+  let offset = 0;
+  const frameInterval = 60;
+
+  const timer = setInterval(() => {
+    offset = (offset + 0.025) % 1;
+    const frameLines = generateBannerFrame(offset).split("\n");
+    let buffer = "\x1b7";
+    for (let index = 0; index < frameLines.length; index += 1) {
+      buffer += `\x1b[${index + 1};1H${frameLines[index]}\x1b[K`;
+    }
+    buffer += "\x1b8";
+    process.stdout.write(buffer);
+  }, frameInterval);
+
+  return {
+    stop: () => {
+      clearInterval(timer);
+    }
+  };
+};
+
+module.exports = {
+  deepseekPalette,
+  bannerLines,
+  interpolateColor,
+  getMultiStopColor,
+  colorTextRgb,
+  generateBannerFrame,
+  renderStaticBanner,
+  startBannerLoop,
+  renderProgressBar
+};

package/src/downloader.js

@@ -0,0 +1,205 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const http = require("http");
+const crypto = require("crypto");
+
+const getFallbackUrls = (url) => {
+  return [
+    `https://ghproxy.net/${url}`,
+    `https://mirror.ghproxy.com/${url}`
+  ];
+};
+
+const verifyFileSize = (filePath, expectedSize) => {
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  const fileStats = fs.statSync(filePath);
+  return fileStats.size === expectedSize;
+};
+
+const verifyFileIntegrity = (filePath, expectedSha256) => {
+  if (!expectedSha256 || !fs.existsSync(filePath)) {
+    return false;
+  }
+  const fileBuffer = fs.readFileSync(filePath);
+  const fileHash = crypto.createHash("sha256").update(fileBuffer).digest("hex");
+  return fileHash === expectedSha256.toLowerCase();
+};
+
+const resolveAssetPath = (preset, localAssetsDir, userCacheDir) => {
+  if (localAssetsDir) {
+    const candidatePath = path.join(localAssetsDir, preset.filename);
+    if (verifyFileSize(candidatePath, preset.expectedSize)) {
+      return candidatePath;
+    }
+    const rootCandidatePath = path.join(localAssetsDir, "..", preset.filename);
+    if (verifyFileSize(rootCandidatePath, preset.expectedSize)) {
+      return rootCandidatePath;
+    }
+  }
+
+  if (userCacheDir) {
+    const cacheCandidatePath = path.join(userCacheDir, preset.filename);
+    if (verifyFileSize(cacheCandidatePath, preset.expectedSize)) {
+      return cacheCandidatePath;
+    }
+  }
+
+  return null;
+};
+
+const getUserCacheDirectory = () => {
+  const homeDirectory = os.homedir();
+  const cachePath = path.join(homeDirectory, ".opencode-deepseek-cache");
+  if (!fs.existsSync(cachePath)) {
+    fs.mkdirSync(cachePath, { recursive: true });
+  }
+  return cachePath;
+};
+
+const downloadStream = (requestUrl, destinationPath, onProgress, timeoutMs, redirectHops = 0) => {
+  return new Promise((resolve, reject) => {
+    if (redirectHops > 5) {
+      reject(new Error("Too many redirects"));
+      return;
+    }
+
+    const parsedUrl = new URL(requestUrl);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+
+    const request = client.get(
+      requestUrl,
+      {
+        timeout: timeoutMs,
+        headers: {
+          "User-Agent": "opencode-deepseek-downloader"
+        }
+      },
+      (response) => {
+        if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+          const redirectLocation = response.headers.location;
+          if (!redirectLocation) {
+            reject(new Error("Redirect header missing"));
+            return;
+          }
+          const nextUrl = new URL(redirectLocation, requestUrl).toString();
+          downloadStream(nextUrl, destinationPath, onProgress, timeoutMs, redirectHops + 1)
+            .then(resolve)
+            .catch(reject);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Server returned HTTP ${response.statusCode}`));
+          return;
+        }
+
+        const totalBytes = parseInt(response.headers["content-length"] || "0", 10);
+        let downloadedBytes = 0;
+
+        const fileStream = fs.createWriteStream(destinationPath);
+
+        response.on("data", (chunk) => {
+          downloadedBytes += chunk.length;
+          if (onProgress && typeof onProgress === "function") {
+            onProgress(downloadedBytes, totalBytes);
+          }
+        });
+
+        response.pipe(fileStream);
+
+        fileStream.on("finish", () => {
+          fileStream.close(() => resolve());
+        });
+
+        fileStream.on("error", (error) => {
+          if (fs.existsSync(destinationPath)) {
+            fs.unlinkSync(destinationPath);
+          }
+          reject(error);
+        });
+      }
+    );
+
+    request.on("timeout", () => {
+      request.destroy();
+      if (fs.existsSync(destinationPath)) {
+        fs.unlinkSync(destinationPath);
+      }
+      reject(new Error("Download connection timed out"));
+    });
+
+    request.on("error", (error) => {
+      if (fs.existsSync(destinationPath)) {
+        fs.unlinkSync(destinationPath);
+      }
+      reject(error);
+    });
+  });
+};
+
+const downloadWithFallback = async (preset, targetPath, onProgress, onFallbackTriggered) => {
+  const temporaryDownloadPath = `${targetPath}.download`;
+  const initialTimeoutMs = 15000;
+  const standardTimeoutMs = 30000;
+
+  const candidateUrls = [preset.remoteUrl, ...getFallbackUrls(preset.remoteUrl)];
+
+  let downloadSucceeded = false;
+  let finalError = null;
+
+  for (let index = 0; index < candidateUrls.length; index += 1) {
+    const currentUrl = candidateUrls[index];
+    const isFallbackAttempt = index > 0;
+    const currentTimeout = isFallbackAttempt ? standardTimeoutMs : initialTimeoutMs;
+
+    if (isFallbackAttempt && onFallbackTriggered) {
+      onFallbackTriggered(currentUrl);
+    }
+
+    try {
+      await downloadStream(
+        currentUrl,
+        temporaryDownloadPath,
+        onProgress,
+        currentTimeout
+      );
+
+      const isValidSize = verifyFileSize(temporaryDownloadPath, preset.expectedSize);
+      const isValidHash = verifyFileIntegrity(temporaryDownloadPath, preset.sha256);
+      if (!isValidSize || !isValidHash) {
+        if (fs.existsSync(temporaryDownloadPath)) {
+          fs.unlinkSync(temporaryDownloadPath);
+        }
+        throw new Error("Downloaded asset failed integrity verification");
+      }
+
+      fs.renameSync(temporaryDownloadPath, targetPath);
+      downloadSucceeded = true;
+      break;
+    } catch (error) {
+      finalError = error;
+      if (fs.existsSync(temporaryDownloadPath)) {
+        fs.unlinkSync(temporaryDownloadPath);
+      }
+    }
+  }
+
+  if (!downloadSucceeded) {
+    throw finalError || new Error("Failed to download asset from all available mirrors");
+  }
+
+  return targetPath;
+};
+
+module.exports = {
+  getFallbackUrls,
+  verifyFileSize,
+  verifyFileIntegrity,
+  resolveAssetPath,
+  getUserCacheDirectory,
+  downloadWithFallback
+};

package/src/engine.js

@@ -0,0 +1,353 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const childProcess = require("child_process");
+const asar = require("@electron/asar");
+
+const isOpenCodeRunning = () => {
+  try {
+    const isWindows = process.platform === "win32";
+    const command = isWindows
+      ? 'tasklist /NH /FI "IMAGENAME eq opencode.exe"'
+      : "pgrep -l -i opencode";
+
+    const output = childProcess.execSync(command, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+
+    return /opencode/i.test(output);
+  } catch {
+    return false;
+  }
+};
+
+const resolveOpenCodePath = () => {
+  const localAppData = process.env.LOCALAPPDATA || "";
+  const candidatePaths = [
+    path.join(localAppData, "Programs", "@opencode-aidesktop"),
+    path.join(localAppData, "Programs", "OpenCode"),
+    path.join(localAppData, "OpenCode")
+  ];
+
+  for (const candidate of candidatePaths) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+};
+
+const encodeImageToBase64 = (filePath) => {
+  const extension = path.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml"
+  };
+  const mimeType = mimeTypes[extension] || "image/png";
+  const buffer = fs.readFileSync(filePath);
+  return `data:${mimeType};base64,${buffer.toString("base64")}`;
+};
+
+const generateThemeCss = (isVideo, base64Url) => {
+  const backgroundRule = isVideo
+    ? `
+#opencode-bg-video {
+  position: fixed !important;
+  top: 0 !important;
+  left: 0 !important;
+  width: 100vw !important;
+  height: 100vh !important;
+  object-fit: cover !important;
+  z-index: -2 !important;
+  pointer-events: none !important;
+}
+`
+    : `
+body::before {
+  content: "" !important;
+  position: fixed !important;
+  inset: 0 !important;
+  background-image: url('${base64Url}') !important;
+  background-size: cover !important;
+  background-position: center !important;
+  background-repeat: no-repeat !important;
+  image-rendering: high-quality !important;
+  z-index: -2 !important;
+  pointer-events: none !important;
+}
+`;
+
+  return `
+:root {
+  --background-base: transparent !important;
+  --background-weak: rgba(16, 26, 48, 0.65) !important;
+  --background-strong: rgba(11, 21, 40, 0.75) !important;
+  --background-stronger: rgba(11, 21, 40, 0.85) !important;
+  --v2-background-bg-base: transparent !important;
+  --v2-background-bg-deep: rgba(11, 21, 40, 0.5) !important;
+  --v2-background-bg-layer-01: rgba(16, 26, 48, 0.6) !important;
+  --v2-background-bg-layer-02: rgba(22, 32, 53, 0.7) !important;
+  --v2-background-bg-layer-03: rgba(30, 42, 68, 0.8) !important;
+  --surface-raised-stronger-non-alpha: #0e172a !important;
+  --surface-raised-base-hover: rgba(77, 107, 254, 0.35) !important;
+}
+${backgroundRule}
+html,
+body,
+#root {
+  background-color: transparent !important;
+  background-image: none !important;
+  color: #e2e8f0 !important;
+}
+
+#root > div,
+#root > div * {
+  background-color: transparent !important;
+}
+
+#root > div {
+  background-color: rgba(10, 14, 26, 0.70) !important;
+  z-index: 1 !important;
+  position: relative !important;
+}
+
+header,
+nav,
+aside,
+[data-slot="titlebar-v2"],
+[data-component="tabs"],
+[data-titlebar-tab],
+.home-session-group-header:after {
+  background-color: transparent !important;
+  background-image: none !important;
+}
+
+[data-titlebar-tab] {
+  background: rgba(16, 26, 48, 0.6) !important;
+  border: 1px solid rgba(77, 107, 254, 0.25) !important;
+  border-radius: 6px !important;
+}
+
+[data-titlebar-tab][data-active="true"] {
+  background: rgba(30, 45, 75, 0.85) !important;
+  border-color: rgba(112, 192, 255, 0.45) !important;
+}
+
+[data-role="user"],
+[data-message-author="user"] {
+  background-color: rgba(77, 107, 254, 0.22) !important;
+  border: 1px solid rgba(77, 107, 254, 0.35) !important;
+  border-radius: 10px !important;
+  padding: 8px 12px !important;
+}
+
+[data-role="assistant"],
+[data-message-author="assistant"] {
+  background-color: rgba(16, 26, 48, 0.75) !important;
+  border: 1px solid rgba(112, 192, 255, 0.25) !important;
+  border-radius: 10px !important;
+  padding: 8px 12px !important;
+}
+
+form,
+textarea,
+input,
+select {
+  background-color: rgba(20, 27, 45, 0.85) !important;
+  border: 1px solid rgba(77, 107, 254, 0.35) !important;
+  color: #f8fafc !important;
+  border-radius: 8px !important;
+}
+
+.monaco-editor,
+.monaco-editor-background,
+.monaco-editor .margin,
+.monaco-editor .overflow-guard,
+pre {
+  background-color: rgba(11, 21, 40, 0.9) !important;
+}
+
+button {
+  background-color: rgba(22, 32, 53, 0.8) !important;
+  border: 1px solid rgba(77, 107, 254, 0.35) !important;
+  color: #f1f5f9 !important;
+  border-radius: 8px !important;
+}
+
+button:hover {
+  background-color: rgba(77, 107, 254, 0.4) !important;
+  border-color: #70c0ff !important;
+}
+
+[data-component="context-menu-content"],
+[data-component="context-menu-sub-content"],
+[data-component="dropdown-menu-content"],
+[data-component="dropdown-menu-sub-content"],
+[data-component="menu-v2-content"],
+[role="menu"] {
+  background-color: rgba(14, 23, 42, 0.94) !important;
+  border: 1px solid rgba(77, 107, 254, 0.35) !important;
+  border-radius: 8px !important;
+  backdrop-filter: blur(16px) !important;
+  -webkit-backdrop-filter: blur(16px) !important;
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.65), 0 0 16px rgba(77, 107, 254, 0.25) !important;
+  color: #f1f5f9 !important;
+}
+
+[data-slot="context-menu-item"],
+[data-slot="context-menu-sub-trigger"],
+[data-slot="dropdown-menu-item"],
+[data-slot="dropdown-menu-sub-trigger"],
+[data-component="menu-v2-item"],
+[role="menuitem"] {
+  color: #e2e8f0 !important;
+  border-radius: 4px !important;
+}
+
+[data-slot="context-menu-item"]:hover,
+[data-slot="context-menu-sub-trigger"]:hover,
+[data-slot="dropdown-menu-item"]:hover,
+[data-slot="dropdown-menu-sub-trigger"]:hover,
+[data-component="menu-v2-item"]:hover,
+[role="menuitem"]:hover,
+[data-slot="context-menu-sub-trigger"][data-expanded],
+[data-slot="dropdown-menu-sub-trigger"][data-expanded],
+[data-highlighted] {
+  background-color: rgba(77, 107, 254, 0.35) !important;
+  color: #ffffff !important;
+}
+
+[data-slot="context-menu-separator"],
+[data-slot="dropdown-menu-separator"],
+[data-slot="menu-v2-separator"] {
+  background-color: rgba(77, 107, 254, 0.25) !important;
+}
+`;
+};
+
+const installTheme = async (itemType, filePath, logFunction) => {
+  const log = logFunction || console.log;
+
+  if (isOpenCodeRunning()) {
+    throw new Error("OPENCODE_RUNNING");
+  }
+
+  const openCodeBasePath = resolveOpenCodePath();
+  if (!openCodeBasePath) {
+    throw new Error("PATH_NOT_FOUND");
+  }
+
+  const resourcesDirectory = path.join(openCodeBasePath, "resources");
+  const appAsarPath = path.join(resourcesDirectory, "app.asar");
+  const appAsarBackupPath = path.join(resourcesDirectory, "app.asar.bak");
+
+  if (!fs.existsSync(appAsarPath) && !fs.existsSync(appAsarBackupPath)) {
+    throw new Error(`app.asar not found in ${resourcesDirectory}`);
+  }
+
+  if (fs.existsSync(appAsarBackupPath)) {
+    fs.copyFileSync(appAsarBackupPath, appAsarPath);
+  } else {
+    fs.copyFileSync(appAsarPath, appAsarBackupPath);
+  }
+
+  if (!filePath || !fs.existsSync(filePath)) {
+    throw new Error(`Background asset not found at: ${filePath}`);
+  }
+
+  const isVideo = itemType === "video";
+  let base64Url = "";
+  if (!isVideo) {
+    base64Url = encodeImageToBase64(filePath);
+  }
+
+  const themeCss = generateThemeCss(isVideo, base64Url);
+
+  const temporaryExtractionPath = path.join(
+    os.tmpdir(),
+    `opencode_patch_${Date.now()}`
+  );
+
+  asar.extractAll(appAsarPath, temporaryExtractionPath);
+
+  const indexHtmlPath = path.join(
+    temporaryExtractionPath,
+    "out",
+    "renderer",
+    "index.html"
+  );
+
+  if (!fs.existsSync(indexHtmlPath)) {
+    fs.rmSync(temporaryExtractionPath, { recursive: true, force: true });
+    throw new Error("index.html not found inside app.asar");
+  }
+
+  let indexHtmlContent = fs.readFileSync(indexHtmlPath, "utf8");
+
+  indexHtmlContent = indexHtmlContent.replace(
+    /<video id="opencode-bg-video"[^>]*><\/video>\s*/gi,
+    ""
+  );
+
+  if (isVideo) {
+    const rendererAssetsDir = path.join(
+      temporaryExtractionPath,
+      "out",
+      "renderer",
+      "assets"
+    );
+    if (!fs.existsSync(rendererAssetsDir)) {
+      fs.mkdirSync(rendererAssetsDir, { recursive: true });
+    }
+    const targetVideoPath = path.join(rendererAssetsDir, "deepseek-bg.mp4");
+    fs.copyFileSync(filePath, targetVideoPath);
+
+    const videoTag = `<video id="opencode-bg-video" autoplay loop muted playsinline src="./assets/deepseek-bg.mp4"></video>`;
+    indexHtmlContent = indexHtmlContent.replace(
+      /(<body[^>]*>)/i,
+      `$1\n    ${videoTag}`
+    );
+  }
+
+  const styleBlock = `<style id="opencode-bg-correct-override">${themeCss}</style>\n</head>`;
+  indexHtmlContent = indexHtmlContent.replace("</head>", styleBlock);
+  fs.writeFileSync(indexHtmlPath, indexHtmlContent, "utf8");
+
+  await asar.createPackage(temporaryExtractionPath, appAsarPath);
+  fs.rmSync(temporaryExtractionPath, { recursive: true, force: true });
+};
+
+const restoreTheme = () => {
+  if (isOpenCodeRunning()) {
+    throw new Error("OPENCODE_RUNNING");
+  }
+
+  const openCodeBasePath = resolveOpenCodePath();
+  if (!openCodeBasePath) {
+    throw new Error("PATH_NOT_FOUND");
+  }
+
+  const resourcesDirectory = path.join(openCodeBasePath, "resources");
+  const appAsarPath = path.join(resourcesDirectory, "app.asar");
+  const appAsarBackupPath = path.join(resourcesDirectory, "app.asar.bak");
+
+  if (!fs.existsSync(appAsarBackupPath)) {
+    throw new Error("BACKUP_NOT_FOUND");
+  }
+
+  fs.copyFileSync(appAsarBackupPath, appAsarPath);
+};
+
+module.exports = {
+  isOpenCodeRunning,
+  resolveOpenCodePath,
+  encodeImageToBase64,
+  generateThemeCss,
+  installTheme,
+  restoreTheme
+};

package/src/i18n.js

@@ -0,0 +1,84 @@
+const locales = {
+  en: {
+    bannerTitle: "Cyber Theme for OpenCode Desktop",
+    selectPrompt: "Select a background preset:",
+    feisha1080: "DeepSeek Féishā (1080p)",
+    zipzip1080: "DeepSeek Maid Whale (ZipZip)",
+    midnight1080: "DeepSeek Midnight (1080p)",
+    static4k: "DeepSeek Artwork (4K)",
+    restoreOption: "Restore original OpenCode design",
+    exitOption: "Exit",
+    downloading: "Downloading asset",
+    downloadFallback: "Retrying using mirror accelerator...",
+    opencodeRunning: "OpenCode Desktop is currently running. Please close it before proceeding.",
+    installSuccess: "DeepSeek Cyber theme installed successfully.",
+    restoreSuccess: "OpenCode Desktop restored to factory state.",
+    pathNotFound: "OpenCode Desktop installation path not found.",
+    error: "Error",
+    changeLangOption: "Change language / 切换语言 / Cambiar idioma",
+    selectLangPrompt: "Select a language:",
+    cancelOption: "Cancel and return to main menu"
+  },
+  zh: {
+    bannerTitle: "OpenCode Desktop DeepSeek 赛博主题",
+    selectPrompt: "请选择背景预设：",
+    feisha1080: "DeepSeek 绯莎 (1080p)",
+    zipzip1080: "DeepSeek 深海女仆 (ZipZip)",
+    midnight1080: "DeepSeek 深夜 (1080p)",
+    static4k: "DeepSeek 插画 (4K)",
+    restoreOption: "恢复 OpenCode 原始默认样式",
+    exitOption: "退出",
+    downloading: "正在下载背景资源",
+    downloadFallback: "正在尝试使用国内镜像加速下载...",
+    opencodeRunning: "检测到 OpenCode Desktop 正在运行，请先关闭该程序再执行安装。",
+    installSuccess: "DeepSeek 赛博主题安装成功！",
+    restoreSuccess: "OpenCode Desktop 已成功恢复出厂默认状态。",
+    pathNotFound: "未找到 OpenCode Desktop 安装路径。",
+    error: "错误",
+    changeLangOption: "切换语言 / Change language / Cambiar idioma",
+    selectLangPrompt: "请选择语言：",
+    cancelOption: "取消并返回主菜单"
+  },
+  es: {
+    bannerTitle: "Tema DeepSeek Cyber para OpenCode Desktop",
+    selectPrompt: "Selecciona un preset de fondo:",
+    feisha1080: "DeepSeek Féishā (1080p)",
+    zipzip1080: "DeepSeek doncella marina (ZipZip)",
+    midnight1080: "DeepSeek medianoche (1080p)",
+    static4k: "DeepSeek artwork (4K)",
+    restoreOption: "Restaurar diseno original de fabrica",
+    exitOption: "Salir",
+    downloading: "Descargando recurso",
+    downloadFallback: "Reintentando mediante espejo acelerado...",
+    opencodeRunning: "OpenCode Desktop esta en ejecucion. Cierralo antes de continuar.",
+    installSuccess: "Tema DeepSeek Cyber instalado con exito.",
+    restoreSuccess: "OpenCode Desktop ha sido restaurado a su estado original.",
+    pathNotFound: "No se detecto la ruta de OpenCode Desktop.",
+    error: "Error",
+    changeLangOption: "Cambiar idioma / Switch language / 切换语言",
+    selectLangPrompt: "Selecciona un idioma:",
+    cancelOption: "Cancelar y volver al menu principal"
+  }
+};
+
+const detectLocale = (explicitLang) => {
+  if (explicitLang && typeof explicitLang === "string" && explicitLang.trim().length > 0) {
+    const normalized = explicitLang.trim().toLowerCase();
+    if (["en", "zh", "es"].includes(normalized)) {
+      return normalized;
+    }
+    return "en";
+  }
+
+  return "en";
+};
+
+const getLocaleStrings = (locale) => {
+  return locales[locale] || locales.en;
+};
+
+module.exports = {
+  locales,
+  detectLocale,
+  getLocaleStrings
+};

package/src/presets.js

@@ -0,0 +1,51 @@
+const presets = [
+  {
+    id: "feisha-1080p",
+    titleKey: "feisha1080",
+    type: "video",
+    filename: "feisha-1080p.mp4",
+    expectedSize: 6445227,
+    sha256: "cce0a170d91fb93f6d97199d5c98078b7c275928a5b852cded1dd582fd5173b5",
+    remoteUrl: "https://github.com/daemon1s/opencode-deepseek-chan/releases/download/v1.0.0/feisha-1080p.mp4"
+  },
+  {
+    id: "zipzip-1080p",
+    titleKey: "zipzip1080",
+    type: "video",
+    filename: "zipzip-1080p.mp4",
+    expectedSize: 11418597,
+    sha256: "4f7e026b2b7bda9b527ab261b896464197bf1fe103897c172404b8431fce2af7",
+    remoteUrl: "https://github.com/daemon1s/opencode-deepseek-chan/releases/download/v1.0.0/zipzip-1080p.mp4"
+  },
+  {
+    id: "midnight-1080p",
+    titleKey: "midnight1080",
+    type: "video",
+    filename: "midnight-1080p.mp4",
+    expectedSize: 20221147,
+    sha256: "f44d1e271cd2e66846b88feefe3bc5478e46c204a7d9d40810dc02c706be98c4",
+    remoteUrl: "https://github.com/daemon1s/opencode-deepseek-chan/releases/download/v1.0.0/midnight-1080p.mp4"
+  },
+  {
+    id: "static-4k",
+    titleKey: "static4k",
+    type: "image",
+    filename: "artwork-4k.png",
+    expectedSize: 9552989,
+    sha256: "fe13cd17bbd9aa48bb6be47cc31ed2f2ab50d74c93d58ccc9af5599322d8f133",
+    remoteUrl: "https://github.com/daemon1s/opencode-deepseek-chan/releases/download/v1.0.0/artwork-4k.png"
+  }
+];
+
+const getPresetById = (id) => {
+  if (!id || typeof id !== "string") {
+    return null;
+  }
+  const normalizedId = id.trim().toLowerCase();
+  return presets.find((preset) => preset.id.toLowerCase() === normalizedId) || null;
+};
+
+module.exports = {
+  presets,
+  getPresetById
+};