dsh-plugin-vrmpet3d 0.1.0 → 0.1.1

package/README.md

@@ -42,6 +42,7 @@ no runtime dependencies · works offline
 | 互动 | 点击与长按部位触发表情和碎碎念；拖动、缩放、旋转视角、视线跟随和弹簧骨物理 |
 | 碎碎念 | 内置台词、自定义台词，或使用 DSH 模型 / OpenAI 兼容接口生成 AI 台词 |
 | 导入 | 模型以文件导入、动作包以文件夹导入，复制到插件存储后不依赖原路径 |
+| 界面语言 | 全部界面中英双语，默认跟随系统 / DSH 自动识别；「通用设置 → 显示与外观」和初次引导欢迎页各有一个语言选择（自动 / 中文 / English） |
 
 ## 运行要求
 
@@ -155,6 +156,7 @@ The marketplace screenshot order is declared in the root [screenshots.json](scre
 | Interaction | Click or hold body parts for expressions and chatter; drag, resize, rotate the view, follow the pointer and use spring-bone physics |
 | Chatter | Built-in or custom lines, or AI-generated lines using a DSH model or an OpenAI-compatible service |
 | Import | Import models as files and motion packs as folders. Imported files are copied into plugin storage and no longer depend on their original paths |
+| Language | The whole interface is Chinese and English, auto-detected from the system or DSH by default; a chooser (Auto / 中文 / English) sits in General settings → Display, and on the first-run guide's welcome screen |
 
 ### Requirements
 

package/desktop/main.js

@@ -37,6 +37,47 @@ const DEFAULT_PET_WINDOW = { width: 240, height: 320 };
  */
 const VRMPET3D_STATUS_PREFIX = 'vrmpet3d-desktop: ';
 
+/**
+ * The words THIS process puts on screen itself: the two native dialog titles and the model filter's name.
+ *
+ * Nothing else here is a string a user reads — every other sentence in this file is a log line or a self-test
+ * report — and these three are the exception because Electron, not a page, draws them. The window title is
+ * deliberately NOT in this table: it names the launcher's own window (`vrmpet3d - model settings`) and is the same
+ * ASCII wherever the user is, so a translated one would add a second name for a window the user finds by that one.
+ *
+ * The launcher is a SEPARATE PROCESS with no access to `lib/core.js`, so it keeps its own copy of the repository's
+ * two-language shape (`{ zh: {...}, en: {...} }`, identical key sets) rather than importing the host's rules.
+ */
+const DIALOG_TEXT = {
+  zh: { motionTitle: '导入动作目录', modelTitle: '导入模型文件', modelFilter: 'VRM / glTF 模型' },
+  en: { motionTitle: 'Import motion folder', modelTitle: 'Import model file', modelFilter: 'VRM / glTF model' },
+};
+
+/**
+ * Which of the two this process draws in, for one request.
+ *
+ * The PAGE wins whenever it says something this process understands. The settings page knows the user's
+ * `preferences.language`, which may be a deliberate 中文 on an English machine or the reverse, so it is the better
+ * authority when it speaks; it may pass that as `{ kind, language }`, and `'auto'` (or nothing at all) is not a
+ * language, so the fallback is `app.getLocale()` — the machine's own locale, which is exactly what `'auto'` means
+ * for a surface with no DSH locale to consult.
+ *
+ * The field is OPTIONAL and nothing here requires it: an older page that sends only `{ kind }` (without a language argument) gets the locale, and a page that sends a value neither of the two languages
+ * ignores it rather than having it guessed at.
+ */
+function dialogLanguage(options) {
+  const wanted = options && typeof options === 'object' ? options.language : null;
+  if (wanted === 'zh' || wanted === 'en') return wanted;
+  let locale = '';
+  try {
+    // After `ready`, which every handler here is; a locale that cannot be read is not a reason to fail a dialog.
+    locale = app.getLocale() || '';
+  } catch (_error) {
+    locale = '';
+  }
+  return /^(zh|cn|chinese)/i.test(String(locale).trim()) ? 'zh' : 'en';
+}
+
 /**
  * The payload the page expects for a cursor sample.
  *
@@ -590,15 +631,16 @@ app.whenReady().then(async () => {
      */
     ipcMain.handle('vrmpet3d:pick-path', async (_event, options) => {
       const kind = options && typeof options === 'object' && options.kind === 'motion' ? 'motion' : 'model';
+      const text = DIALOG_TEXT[dialogLanguage(options)] || DIALOG_TEXT.en;
       try {
         const result = await dialog.showOpenDialog(win, kind === 'motion' ? {
-          title: '导入动作目录',
+          title: text.motionTitle,
           properties: ['openDirectory'],
           defaultPath: app.getPath('home'),
         } : {
-          title: '导入模型文件',
+          title: text.modelTitle,
           properties: ['openFile'],
-          filters: [{ name: 'VRM / glTF 模型', extensions: ['vrm', 'glb', 'gltf'] }],
+          filters: [{ name: text.modelFilter, extensions: ['vrm', 'glb', 'gltf'] }],
           defaultPath: app.getPath('home'),
         });
         if (result.canceled || !Array.isArray(result.filePaths) || !result.filePaths.length) return null;

package/desktop/preload.js

@@ -39,7 +39,9 @@ contextBridge.exposeInMainWorld('vrmpet3dDesktop', {
    * plugin's own storage. The host stays the only writer of that list, and the `VRMPET3D_MODEL_FILES_FILE` /
    * `VRMPET3D_IMPORT_DIR` overrides the suites rely on are not bypassed.
    */
-  pickModelFile: () => ipcRenderer.invoke('vrmpet3d:pick-path', { kind: 'model' }),
+  pickModelFile: (language) => ipcRenderer.invoke('vrmpet3d:pick-path', {
+    kind: 'model', language: language === 'zh' || language === 'en' ? language : undefined,
+  }),
 
   /**
    * The same dialog for an imported MOTION folder (`/vrmpet3d/motions`), which stays a DIRECTORY: a motion pack is
@@ -47,7 +49,9 @@ contextBridge.exposeInMainWorld('vrmpet3dDesktop', {
    *
    * One channel for both, with `kind` deciding a FILE dialog from a folder one and the title each shows.
    */
-  pickMotionDir: () => ipcRenderer.invoke('vrmpet3d:pick-path', { kind: 'motion' }),
+  pickMotionDir: (language) => ipcRenderer.invoke('vrmpet3d:pick-path', {
+    kind: 'motion', language: language === 'zh' || language === 'en' ? language : undefined,
+  }),
 
   /**
    * Tell the launcher that a VIEW ORBIT is starting or ending — and let IT take the pointer lock.

package/lib/client.core.js

@@ -79,16 +79,32 @@
    * The `{duration}` token and its machinery stay — a line the user writes may still carry it (see
    * {@link STATUS_DURATION_TOKEN}) — but the shipped line is DSH's token-free 「深度求索中 ···」, which is also what the
    * app shows while the latest turn is not open.
+   *
+   * ONE TABLE PER LANGUAGE, keyed state → language, the same shape `SPEECH_LINES` uses for its pools and for the
+   * same reason: a status line is TEXT THE USER READS, so an interface in English that still said 「任务达成」 would
+   * be a half-translated one. The two halves are written rather than translated word for word, and the Chinese is
+   * the operator's own wording, unchanged since 2026-10-13.
+   *
+   * An EDIT wins over both: `statusEntryFor` only reaches for these while the user's own box is empty, so a line
+   * typed by hand is one line in one language and stays exactly that, in either interface language. That is the
+   * whole reason this is a per-language DEFAULT rather than a second field in the settings.
    */
   var DEFAULT_STATUS_TEXT = {
-    resting: '',
-    working: '深度求索中 ···',
-    waiting: '我有问题要问你',
-    done: '任务达成',
-    error: '遇到问题了...',
-    offline: '',
+    resting: { zh: '', en: '' },
+    working: { zh: '深度求索中 ···', en: 'Working ···' },
+    waiting: { zh: '我有问题要问你', en: 'I have a question for you' },
+    done: { zh: '任务达成', en: 'Task complete' },
+    error: { zh: '遇到问题了...', en: 'Something went wrong...' },
+    offline: { zh: '', en: '' },
   };
 
+  /** One state's shipped line in one language; `''` for a state that says nothing by default. */
+  function defaultStatusText(state, language) {
+    var entry = DEFAULT_STATUS_TEXT[state];
+    if (!entry || typeof entry !== 'object') return '';
+    return typeof entry[language === 'en' ? 'en' : 'zh'] === 'string' ? entry[language === 'en' ? 'en' : 'zh'] : '';
+  }
+
   /**
    * The token a status line may carry where the live elapsed time goes, and the units it is written with.
    *
@@ -104,6 +120,155 @@
     en: { hour: 'h ', minute: 'm ', second: 's' },
   };
 
+  /**
+   * The three answers to 「界面语言」, and the ONE rule that turns them into the language a surface draws in.
+   *
+   * `auto` is the shipped answer and means "whatever the surface is already running in": DSH's own locale inside
+   * the app, the browser's on a host-served page, and on a surface that can see neither (a suite, a headless
+   * host) English — the plugin's own fallback rather than a guess about the operator.
+   *
+   * The other two are the user overruling that, and they exist because the two questions are NOT the same one:
+   * DSH can be running in English while its owner wants the pet in Chinese, and the first-run guide is read once,
+   * before any of that has settled. Operator, 2026-10-15: 「把全部界面做中英双语自动识别，并在通用设置和初始安装
+   * 引导页的第一页欢迎页面中加上语言选择」.
+   *
+   * `auto` is STORED as `auto`, never resolved on write. A profile that stored the resolved 'zh' would freeze the
+   * language on the day it was created, and the user who later switched DSH to English would keep a Chinese pet
+   * with no way to tell that from a deliberate choice — the same mistake `DEFAULTS.petSurface` documents for
+   * 显示位置, and it is why this is a preference the CLEANER knows about rather than a value a page writes.
+   */
+  var LANGUAGE_SETTINGS = ['auto', 'zh', 'en'];
+
+  /** `'auto'` for anything that is not one of the three — an unknown stored value is a reset, not an error. */
+  function cleanLanguage(value) {
+    return LANGUAGE_SETTINGS.indexOf(value) === -1 ? 'auto' : value;
+  }
+
+  /**
+   * Which of the two languages this surface draws in, given the user's setting and what the environment says.
+   *
+   * `hints` is a LIST, most authoritative first — DSH's locale, then the document's own `lang`, then
+   * `navigator.language` — and the FIRST hint that says anything decides. That order is the rule and not a detail:
+   * DSH is the application the pet lives inside, so its language outranks the browser's, and a page DSH has
+   * already marked `lang="zh"` outranks a browser whose own preference is en-US.
+   *
+   * The first hint decides the ZH-or-not question instead of the chain continuing past it, because this plugin has
+   * exactly two languages. A hint of `fr` is not a reason to go looking for a Chinese one further down the chain;
+   * it is a reason to fall back to English, which is also what `auto` with nothing to go on means.
+   */
+  function resolveLanguage(preference, hints) {
+    var wanted = cleanLanguage(preference);
+    if (wanted !== 'auto') return wanted;
+    var list = Array.isArray(hints) ? hints : [hints];
+    for (var i = 0; i < list.length; i += 1) {
+      var hint = list[i];
+      if (typeof hint !== 'string' || !hint) continue;
+      return /^(zh|cn|chinese)/i.test(hint.trim()) ? 'zh' : 'en';
+    }
+    return 'en';
+  }
+
+  /**
+   * The environment's own two hints, in the order they outrank each other — what a surface that has no DSH locale
+   * to ask uses. `scope` exists so a suite can hand in a fake window instead of moving the real one.
+   *
+   * The BROWSER comes first, and the document's own `lang` second, which is the opposite of the order the app's
+   * widget uses — deliberately. Every page this plugin serves ships `<html lang="zh">` (the plugin was written in
+   * Chinese), so a page that read its own markup first could never be auto-detected as English: the hint would be
+   * its own default rather than anything about the user. `navigator.language` is the browser's answer and in the
+   * floating window it is Electron's, i.e. the machine's.
+   */
+  function browserLanguageHints(scope) {
+    var win = scope || (typeof globalThis !== 'undefined' ? globalThis : null);
+    var doc = win && win.document;
+    var nav = win && win.navigator;
+    return [
+      nav ? (nav.language || (nav.languages && nav.languages[0])) : null,
+      doc && doc.documentElement ? doc.documentElement.lang : null,
+    ];
+  }
+
+  /**
+   * One surface's own wording, in the two languages, chosen by {@link resolveLanguage}.
+   *
+   * Every surface keeps its OWN table — `lib/menu.js`'s `LABELS`, `lib/model-picker.js`'s `TEXT`, the settings
+   * pages' `TEXT` — rather than one global dictionary, because that is already this repository's shape (a surface
+   * owns the words it draws) and because a single table for six surfaces would make every one of them edit the
+   * same file. What IS shared is the SHAPE: `{ zh: {...}, en: {...} }`, this accessor, and {@link applyI18n}.
+   *
+   * A language half that is missing or empty falls back to the other one rather than to blank: a half-translated
+   * surface reads as Chinese in one spot, which is a bug somebody reports, where a blank label is a page that
+   * looks broken. `textOf` below is what makes a GAP visible, and a suite is what keeps one from shipping.
+   */
+  function textFor(table, language) {
+    if (!table || typeof table !== 'object') return {};
+    var wanted = language === 'en' ? table.en : table.zh;
+    var other = language === 'en' ? table.zh : table.en;
+    if (wanted && typeof wanted === 'object') return wanted;
+    return other && typeof other === 'object' ? other : {};
+  }
+
+  /** One entry out of a surface's table. A missing key returns the KEY, so a gap is visible on screen. */
+  function textOf(table, language, key) {
+    var value = textFor(table, language)[key];
+    return typeof value === 'string' ? value : key;
+  }
+
+  /**
+   * Fill a document's marked-up text from one surface's table.
+   *
+   * The markup carries the CHINESE text as well as the key, and that is on purpose: this plugin's pages all ship a
+   * bootstrap watchdog for the case where a script never ran, so a page whose script DID not run should still say
+   * something in one language rather than show nothing. `verify-desktop.mjs` asserts the two agree, which is what
+   * stops the markup and the table from drifting apart.
+   *
+   * Four attributes, one per place text lives: `data-i18n` writes `textContent`, `data-i18n-html` writes
+   * `innerHTML` and is for OUR OWN sentence with a `<strong>` in it (never for anything a user or a model wrote),
+   * and `data-i18n-placeholder` / `data-i18n-title` / `data-i18n-aria` write those three attributes.
+   *
+   * A key the table does not have leaves the markup ALONE rather than printing the key: the visible text stays the
+   * Chinese fallback, and the missing entry is the suite's business, not the user's.
+   *
+   * @returns {number} how many places were rewritten, so a suite can tell "applied nothing" from "no markup".
+   */
+  function applyI18n(root, table, language) {
+    var doc = root && typeof root.querySelectorAll === 'function'
+      ? root
+      : (typeof globalThis !== 'undefined' ? globalThis.document : null);
+    if (!doc || typeof doc.querySelectorAll !== 'function') return 0;
+    var words = textFor(table, language);
+    var selector = '[data-i18n],[data-i18n-html],[data-i18n-placeholder],[data-i18n-title],[data-i18n-aria]';
+    var nodes;
+    try {
+      nodes = doc.querySelectorAll(selector);
+    } catch (error) {
+      return 0;
+    }
+    var applied = 0;
+    var write = function (node, attribute, key, html) {
+      var value = words[key];
+      if (typeof value !== 'string') return;
+      if (attribute === 'data-i18n') node.textContent = value;
+      else if (html) node.innerHTML = value;
+      else node.setAttribute(attribute, value);
+      applied += 1;
+    };
+    for (var i = 0; i < nodes.length; i += 1) {
+      var node = nodes[i];
+      var key = node.getAttribute('data-i18n');
+      if (key) write(node, 'data-i18n', key, false);
+      key = node.getAttribute('data-i18n-html');
+      if (key) write(node, 'data-i18n-html', key, true);
+      key = node.getAttribute('data-i18n-placeholder');
+      if (key) write(node, 'placeholder', key, false);
+      key = node.getAttribute('data-i18n-title');
+      if (key) write(node, 'title', key, false);
+      key = node.getAttribute('data-i18n-aria');
+      if (key) write(node, 'aria-label', key, false);
+    }
+    return applied;
+  }
+
   /**
    * The states whose prompt carries DSH's whale mark.
    *
@@ -1088,6 +1253,12 @@
   /** Default pose and behaviour knobs. */
   var DEFAULTS = {
     scope: 'global',
+    /**
+     * 界面语言 — `auto` follows the surface's own environment ({@link resolveLanguage}), and 中文 / English overrule
+     * it. It sits first in the table rather than beside the appearance rows because it is the one preference that
+     * decides how every OTHER row is spelled.
+     */
+    language: 'auto',
     size: 100,
     /**
      * WHERE the pet is shown, as the cleaner's DEFAULT rather than a string repeated beside it.
@@ -1933,6 +2104,13 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     var out = {};
     var source = raw && typeof raw === 'object' ? raw : {};
     out.scope = source.scope === 'current' ? 'current' : 'global';
+    /**
+     * 界面语言 — cleaned like every other enumerated preference: an unknown value (an older profile, a typo, a page
+     * that sent the wrong thing) is `auto`, which resolves to the surface's own environment anyway. It is NOT
+     * counted as authorship by `authoredWeight` over in `lib/settings.js`: a language is a way of looking at the
+     * pet, not something the user wrote into it.
+     */
+    out.language = cleanLanguage(source.language);
     // An unknown surface falls back to the shipped default, not to a string repeated here.
     out.petSurface = PET_SURFACES.indexOf(source.petSurface) === -1 ? DEFAULTS.petSurface : source.petSurface;
     out.size = Number.isFinite(Number(source.size)) ? clamp(Number(source.size), SIZE_RANGE.min, SIZE_RANGE.max) : DEFAULTS.size;
@@ -2488,8 +2666,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
   // ---------------------------------------------------------------------------
 
   /** One state's status line, exactly as the renderer draws it: text, then the tag. */
-  function statusLineFor(preferences, state) {
-    var entry = statusEntryFor(preferences, state);
+  function statusLineFor(preferences, state, language) {
+    var entry = statusEntryFor(preferences, state, language);
     if (!entry) return '';
     var tag = typeof entry.tag === 'string' ? entry.tag : '';
     return (entry.text + tag).slice(0, STATUS_LIMITS.textLength + STATUS_LIMITS.tagLength);
@@ -2501,11 +2679,15 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * Always an OBJECT, never null: every state has something to say or an explicit reason to say nothing,
    * and a caller that had to distinguish "unconfigured" from "configured empty" would get it wrong in the
    * one case that matters (a user who cleared a line).
+   *
+   * `language` picks WHICH shipped default fills an empty box — see {@link DEFAULT_STATUS_TEXT}. It is the third
+   * parameter and optional, so a caller that does not know the surface's language keeps the Chinese default the
+   * suites and the older call sites already pin.
    */
-  function statusEntryFor(preferences, state) {
+  function statusEntryFor(preferences, state, language) {
     var map = preferences && preferences.status && typeof preferences.status === 'object' ? preferences.status : {};
     var stored = map[state] && typeof map[state] === 'object' ? map[state] : {};
-    var fallback = Object.prototype.hasOwnProperty.call(DEFAULT_STATUS_TEXT, state) ? DEFAULT_STATUS_TEXT[state] : '';
+    var fallback = defaultStatusText(state, language);
     var text = typeof stored.text === 'string' ? stored.text : fallback;
     var fallbackAnimation = Object.prototype.hasOwnProperty.call(DEFAULT_STATUS_ANIMATION, state)
       ? DEFAULT_STATUS_ANIMATION[state]
@@ -3634,11 +3816,17 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * clause is DROPPED — DSH's own token-free 「深度求索中」 rather than a number invented here. Passed per call so the
    * two surfaces (the app's pet and the floating window) can only differ by what they are told, never by the rule.
    *
+   * `language` is the SIXTH parameter and it reaches two places: which shipped default an empty box falls back to
+   * ({@link DEFAULT_STATUS_TEXT}), and the units a `{duration}` clause is written in — DSH writes 1分30秒 in one
+   * language and 1m 30s in the other, so a line translated without its clock would read as a foreign number.
+   * Optional, like the status-entry language above: a caller that has no language to pass keeps the Chinese answer
+   * every existing suite pins.
+   *
    * @returns {{state: string, text: string, tag: string, animation: string, seconds: number}|null}
    */
-  function statusFor(preferences, state, enteredAt, now, clock) {
+  function statusFor(preferences, state, enteredAt, now, clock, language) {
     if (STATUS_STATES.indexOf(state) === -1) return null;
-    var entry = statusEntryFor(preferences, state);
+    var entry = statusEntryFor(preferences, state, language);
     if (!entry.text && !entry.tag) return null;
     var at = Number.isFinite(now) ? now : Date.now();
     /**
@@ -3691,7 +3879,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       }
       text = elapsed === null
         ? durationClauseRemoved(text)
-        : text.split(STATUS_DURATION_TOKEN).join(formatRunDuration(elapsed));
+        : text.split(STATUS_DURATION_TOKEN).join(formatRunDuration(elapsed, language));
     }
     var look = statusTone(state);
     return {
@@ -7307,6 +7495,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     STATES: STATES,
     INTERACTION_STATES: INTERACTION_STATES,
     STATUS_STATES: STATUS_STATES,
+    LANGUAGE_SETTINGS: LANGUAGE_SETTINGS,
+    cleanLanguage: cleanLanguage,
+    resolveLanguage: resolveLanguage,
+    browserLanguageHints: browserLanguageHints,
+    textFor: textFor,
+    textOf: textOf,
+    applyI18n: applyI18n,
+    defaultStatusText: defaultStatusText,
     DEFAULT_STATUS_TEXT: DEFAULT_STATUS_TEXT,
     STATUS_TAGS: STATUS_TAGS,
     STATUS_ANIMATIONS: STATUS_ANIMATIONS,