dsh-model-groups 0.0.0-stage → 0.3.3

package/scripts/native-patches.mjs

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+export const ARTIFACTS = ['pi-ai.patch.json', 'settings-models.patch.json', 'llm-typert.host.patch.json', 'llm-typert.remote-client.patch.json', 'api-remotes.patch.json'];
+const pluginRoot = fileURLToPath(new URL('../', import.meta.url));
+export const sha256 = source => crypto.createHash('sha256').update(source).digest('hex');
+const inside = (root, target) => target.startsWith(root + path.sep);
+
+export function transformSource(source, artifact, reverse = false) {
+  let result = source;
+  const replacements = reverse ? [...artifact.replacements].reverse() : artifact.replacements;
+  for (const replacement of replacements) {
+    const before = reverse ? replacement.after : replacement.before;
+    const after = reverse ? replacement.before : replacement.after;
+    if (typeof before !== 'string' || before.length === 0 || typeof after !== 'string') throw new Error('Invalid literal replacement');
+    if (!result.includes(before)) throw new Error('Patch source did not match; no files written');
+    result = result.split(before).join(after);
+  }
+  const expected = reverse ? artifact.baseSha256 : artifact.resultSha256;
+  if (sha256(result) !== expected) throw new Error('Patch result hash mismatch; no files written');
+  return result;
+}
+
+/** Validate ALL files before any modification. Check mode is read-only. */
+export function planPatches(dshRoot, mode = 'check', artifactDirectory = path.join(pluginRoot, 'native')) {
+  if (!['check', 'apply', 'revert'].includes(mode)) throw new Error('Unknown patch mode');
+  const root = fs.realpathSync(dshRoot);
+  const inner = path.join(root, 'node_modules/@deepseek-ai/dsh/package.json');
+  const dsh = JSON.parse(fs.readFileSync(fs.existsSync(inner) ? inner : path.join(root, 'package.json'), 'utf8'));
+  if (dsh.name !== '@deepseek-ai/dsh' || dsh.version !== '0.2.2-rc.1') throw new Error('This patch supports only @deepseek-ai/dsh 0.2.2-rc.1');
+  const seen = new Set();
+  return ARTIFACTS.map(name => {
+    const artifact = JSON.parse(fs.readFileSync(path.join(artifactDirectory, name), 'utf8'));
+    if (artifact.version !== '0.2.2-rc.1' || !/^@deepseek-ai\/dsh-[a-z-]+$/.test(artifact.packageName)) throw new Error('Unsupported patch package/version');
+    if (!Array.isArray(artifact.replacements) || artifact.replacements.length === 0 || !/^[0-9a-f]{64}$/.test(artifact.baseSha256) || !/^[0-9a-f]{64}$/.test(artifact.resultSha256)) throw new Error('Invalid patch manifest');
+    const prefix = `node_modules/${artifact.packageName}/`;
+    if (typeof artifact.target !== 'string' || !artifact.target.startsWith(prefix) || artifact.target.includes('..') || artifact.target.includes('\\')) throw new Error('Unsafe patch target');
+    const file = path.resolve(root, artifact.target);
+    if (!inside(root, file) || fs.realpathSync(file) !== file || !fs.statSync(file).isFile() || seen.has(file)) throw new Error('Unexpected target path or duplicate patch');
+    seen.add(file);
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'node_modules', artifact.packageName, 'package.json'), 'utf8'));
+    if (pkg.name !== artifact.packageName || pkg.version !== artifact.version) throw new Error('Installed native package version mismatch');
+    const source = fs.readFileSync(file, 'utf8');
+    const hash = sha256(source);
+    const state = hash === artifact.baseSha256 ? 'pristine' : hash === artifact.resultSha256 ? 'patched' : 'modified';
+    if (state === 'modified') throw new Error(`Refusing unrecognized content: ${artifact.target}`);
+    // A no-op still verifies both directions to detect a broken manifest.
+    const reverse = state === 'patched';
+    const transformed = transformSource(source, artifact, reverse);
+    const result = (mode === 'apply' && state === 'pristine') || (mode === 'revert' && state === 'patched') ? transformed : source;
+    return { name, artifact, file, source, result, state, mode: fs.statSync(file).mode & 0o777 };
+  });
+}
+
+function stageReplacement(file, content, mode) {
+  // Only replace an observed regular target, with a same-directory atomic rename.
+  if (!path.isAbsolute(file) || fs.realpathSync(file) !== file || !fs.lstatSync(file).isFile()) throw new Error('Unexpected native target before write');
+  const temporary = `${file}.dsh-multikey-${crypto.randomUUID()}.tmp`;
+  const fd = fs.openSync(temporary, 'wx', mode);
+  try {
+    fs.writeFileSync(fd, content, 'utf8');
+    fs.fsyncSync(fd);
+  } catch (error) {
+    fs.closeSync(fd);
+    discardStaged(temporary, file);
+    throw error;
+  }
+  fs.closeSync(fd);
+  return temporary;
+}
+function discardStaged(temporary, file) {
+  if (!path.isAbsolute(temporary) || !temporary.startsWith(`${file}.dsh-multikey-`) || path.dirname(temporary) !== path.dirname(file) || !temporary.endsWith('.tmp')) throw new Error('Unsafe staged native path');
+  if (fs.existsSync(temporary)) {
+    if (fs.realpathSync(temporary) !== temporary || !fs.lstatSync(temporary).isFile()) throw new Error('Unexpected staged native file');
+    fs.unlinkSync(temporary);
+  }
+}
+export function applyPlan(plans, backupDirectory = path.join(pluginRoot, 'native', 'backups')) {
+  const changed = plans.filter(plan => plan.source !== plan.result);
+  // Re-check all inputs just before writing. Never overwrite concurrent edits.
+  for (const plan of plans) if (fs.readFileSync(plan.file, 'utf8') !== plan.source) throw new Error('Concurrent native edit; no files written');
+  if (changed.length === 0) return 0;
+  fs.mkdirSync(backupDirectory, { recursive: true });
+  for (const plan of changed) {
+    const backup = path.join(backupDirectory, `${plan.artifact.packageName.slice('@deepseek-ai/'.length)}-${path.basename(plan.file)}-${sha256(plan.source)}.js`);
+    if (fs.existsSync(backup)) {
+      if (sha256(fs.readFileSync(backup)) !== sha256(plan.source)) throw new Error('Backup hash mismatch; no files written');
+    } else fs.writeFileSync(backup, plan.source, { mode: 0o600, flag: 'wx' });
+  }
+  const staged = [];
+  const written = [];
+  try {
+    // Finish every write before replacing any target; a disk error cannot truncate it.
+    for (const plan of changed) staged.push({ plan, temporary: stageReplacement(plan.file, plan.result, plan.mode) });
+    for (const { plan, temporary } of staged) {
+      if (fs.realpathSync(plan.file) !== plan.file || fs.readFileSync(plan.file, 'utf8') !== plan.source) throw new Error('Concurrent native edit');
+      fs.renameSync(temporary, plan.file);
+      written.push(plan);
+    }
+  } catch (error) {
+    for (const plan of written.reverse()) {
+      if (fs.realpathSync(plan.file) === plan.file && fs.readFileSync(plan.file, 'utf8') === plan.result) {
+        const temporary = stageReplacement(plan.file, plan.source, plan.mode);
+        try { fs.renameSync(temporary, plan.file); } finally { discardStaged(temporary, plan.file); }
+      }
+    }
+    throw error;
+  } finally {
+    for (const { plan, temporary } of staged) discardStaged(temporary, plan.file);
+  }
+  return changed.length;
+}
+
+function main(args) {
+  if (args.includes('--help')) {
+    console.log('Usage: node scripts/native-patches.mjs --dsh-root <installed-DSH-root> [--check|--apply|--revert]\nDefault: read-only --check. Stop DSH before apply/revert, then restart the same service and refresh its existing page. Never revert while saved sessions still select @dsh-key/ aliases.');
+    return;
+  }
+  const modes = args.filter(arg => ['--check', '--apply', '--revert'].includes(arg));
+  if (modes.length > 1) throw new Error('Choose one mode');
+  const i = args.indexOf('--dsh-root');
+  if (i === -1 || !args[i + 1]) throw new Error('Supply an explicit --dsh-root; see --help');
+  const allowed = new Set(['--check', '--apply', '--revert', '--dsh-root', args[i + 1]]);
+  if (args.some(arg => !allowed.has(arg))) throw new Error('Unknown argument');
+  const mode = (modes[0] ?? '--check').slice(2);
+  const plans = planPatches(args[i + 1], mode);
+  for (const plan of plans) console.log(`${plan.artifact.target}: ${plan.state}`);
+  if (mode !== 'check') console.log(`${applyPlan(plans)} native files changed. Restart the existing DSH service and refresh its page; the live process is not reloaded by this script.`);
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try { main(process.argv.slice(2)); }
+  catch (error) { console.error(error.message); process.exitCode = 1; }
+}

package/src/client.js

@@ -0,0 +1,33 @@
+const groupPreferences = createGroupPreferences();
+const EMPTY_PROVIDERS_SNAPSHOT = Object.freeze({ status: 'unavailable', value: {} });
+
+const inject = ['slots', 'modelDirectories', 'sessions', 'locale', 'remote', 'remote.session', 'remote.llm', 'configForms'];
+export function apply(ctx) {
+  installModelSelectStyles();
+  installModelGroupsStyles();
+  const providersForm = ctx.configForms?.get('llm-pi-ai');
+  const onStorage = event => {
+    if (event.key === STORAGE_KEY || event.key === null) groupPreferences.sync(event.key === null ? null : event.newValue);
+  };
+  window.addEventListener('storage', onStorage);
+  ctx.on('dispose', () => {
+    window.removeEventListener('storage', event => onStorage(event));
+    document.querySelectorAll('style[data-plugin="dsh-model-groups"]').forEach(style => style.remove());
+  });
+  return ctx.slots.inject('conversation.input.model', () => ctx.slots.register({
+    name: 'conversation.input.model',
+    priority: -10,
+    locale: 'model',
+    inject(sessionId) {
+      const directory = ctx.modelDirectories.directoryFor(sessionId);
+      const available = ctx.sessions.subagentAddress(sessionId) === undefined;
+      return {
+        available,
+        directory: directory.store,
+        providersForm,
+        load() { if (available) directory.load().catch(() => {}); },
+        select: selection => available ? directory.select(selection) : Promise.resolve(undefined),
+      };
+    },
+  }, ModelSeatBoundary));
+}

package/src/fallback.js

@@ -0,0 +1,69 @@
+// Degraded but usable selector: shown only if the grouped picker itself throws.
+// Deliberately primitive-free and flat so it cannot fail the same way.
+function FallbackModelSelect({ available, directory, select, t, providersForm }) {
+	const state = (0, react.useSyncExternalStore)((fn) => directory.subscribe(fn), () => directory.getSnapshot());
+	const configuration = react.useSyncExternalStore(fn => providersForm?.subscribe(fn) ?? (() => {}), () => providersForm?.getSnapshot() ?? EMPTY_PROVIDERS_SNAPSHOT);
+	const providers = configuration.status === 'ready' ? (configuration.value?.providers ?? {}) : undefined;
+	const [open, setOpen] = (0, react.useState)(false);
+	if (!available) return null;
+	const label = typeof t === 'function' ? t('menu.model') : '模型';
+	const current = state.current ?? null;
+	const models = (state.groups ?? []).flatMap(group => {
+		const profile = Object.hasOwn(providers ?? {}, group.id) ? providers[group.id] : undefined;
+		const multi = profile?.multiKey === true || (providers === undefined && group.models.some(model => decodeKeyModelId(model.id)));
+		return group.models.flatMap(model => {
+			const key = decodeKeyModelId(model.id);
+			if (key) {
+				if (!multi || (providers !== undefined && !Object.hasOwn(profile?.keyEntries ?? {}, key.entryId))) return [];
+			} else if (model.id.startsWith(KEY_MODEL_PREFIX) || (multi && (current?.provider !== group.id || current?.model !== model.id))) return [];
+			const providerName = group.name ?? group.id;
+			return [{ provider: group.id, providerName: key ? `${providerName} / ${keyEntryName(providers, group.id, key.entryId)}` : providerName, model }];
+		});
+	});
+	const active = models.find((entry) => entry.provider === current?.provider && entry.model.id === current?.model);
+	const choose = (entry) => {
+		setOpen(false);
+		select({
+			provider: entry.provider,
+			model: entry.model.id,
+			...(entry.model.reasoning?.defaultEffort === void 0 ? {} : { reasoningEffort: entry.model.reasoning.defaultEffort }),
+		});
+	};
+	return react.createElement('div', { className: 'dsh-mg-root' },
+		react.createElement('button', {
+			type: 'button',
+			className: 'dsh-mg-trigger',
+			'aria-haspopup': 'menu',
+			'aria-expanded': open,
+			onClick: () => setOpen(!open),
+		}, react.createElement('span', { className: 'dsh-mg-triggerLabel' }, active?.model.name ?? current?.model ?? label)),
+		open ? react.createElement('div', { className: 'dsh-mg-menu', role: 'menu', style: { left: 12, bottom: 60, top: 'auto' } },
+			models.map((entry) => react.createElement('button', {
+				key: entry.provider + '/' + entry.model.id,
+				type: 'button',
+				role: 'menuitemradio',
+				'aria-checked': entry === active,
+				className: 'dsh-mg-row',
+				onClick: () => choose(entry),
+			}, entry.model.name ?? entry.model.id, react.createElement('span', { className: 'dsh-mg-rowHint' }, entry.providerName)))) : null);
+}
+
+// Last line of defence: a broken grouped picker must never blank the model seat.
+class ModelSeatBoundary extends react.Component {
+	static getDerivedStateFromError() {
+		return { failed: true };
+	}
+	constructor(props) {
+		super(props);
+		this.state = { failed: false };
+	}
+	componentDidCatch(error) {
+		try {
+			console.error('[dsh-model-groups] grouped picker failed, falling back', error);
+		} catch {}
+	}
+	render() {
+		if (this.state.failed) return react.createElement(FallbackModelSelect, this.props);
+		return react.createElement(ModelSelect, this.props);
+	}
+}

package/src/group-state.js

@@ -0,0 +1,61 @@
+// Only display preferences live here; no models, credentials, or session data.
+export const STORAGE_KEY = 'dsh:model-groups:v1';
+export const MODE_STORAGE_KEY = 'dsh:model-groups:mode';
+
+export function getMenuMode(getStorage = () => globalThis.localStorage) {
+  try {
+    const val = getStorage()?.getItem(MODE_STORAGE_KEY);
+    return val === 'inline' ? 'inline' : 'panel';
+  } catch {
+    return 'panel';
+  }
+}
+
+export function setMenuMode(mode, getStorage = () => globalThis.localStorage) {
+  try {
+    getStorage()?.setItem(MODE_STORAGE_KEY, mode === 'inline' ? 'inline' : 'panel');
+  } catch { /* private mode */ }
+}
+
+export function parsePreferences(text) {
+  try {
+    const value = JSON.parse(text);
+    if (value?.version !== 1 || !value.expanded || Array.isArray(value.expanded)) return {};
+    return Object.fromEntries(Object.entries(value.expanded).filter(([, expanded]) => typeof expanded === 'boolean'));
+  } catch {
+    return {};
+  }
+}
+
+export function isGroupExpanded(preferences, providerId, currentProvider) {
+  return Object.hasOwn(preferences, providerId) ? preferences[providerId] : providerId === currentProvider;
+}
+
+/** Search reveals matching models without changing the saved group preference. */
+export function visibleModelGroups(groups, preferences, currentProvider, searching) {
+  return groups.map(group => ({
+    ...group,
+    expanded: searching || isGroupExpanded(preferences, group.id, currentProvider),
+  }));
+}
+
+/** A storage failure degrades to in-memory preferences, never breaks the picker. */
+export function createGroupPreferences(getStorage = () => globalThis.localStorage) {
+  let preferences = {};
+  const listeners = new Set();
+  const publish = next => {
+    preferences = next;
+    for (const listener of listeners) listener();
+  };
+  try { preferences = parsePreferences(getStorage()?.getItem(STORAGE_KEY)); } catch { /* private mode */ }
+  return {
+    getSnapshot: () => preferences,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    setExpanded(providerIds, expanded) {
+      const next = { ...preferences, ...Object.fromEntries(providerIds.map(id => [id, expanded])) };
+      publish(next);
+      try { getStorage()?.setItem(STORAGE_KEY, JSON.stringify({ version: 1, expanded: next })); } catch { /* quota / private mode */ }
+    },
+    sync(text) { publish(parsePreferences(text)); },
+  };
+}

package/src/groups.css

@@ -0,0 +1,280 @@
+/* DSH Model Groups: 100% native token-compatible styling */
+
+.dsh-mg-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 4px;
+  flex-shrink: 0;
+  margin: 2px 0 4px;
+  padding: 0 4px;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+.dsh-mg-summary {
+  flex: 1;
+  min-width: 0;
+  padding: 0 2px;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  line-height: 16px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.dsh-mg-toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  flex: none;
+}
+
+.dsh-mg-toolbar button {
+  flex: none;
+  height: 22px;
+  padding: 0 6px;
+  border: 0;
+  border-radius: var(--dsw-radius-sm);
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  font-size: 11px;
+  line-height: 22px;
+  cursor: pointer;
+  transition: background .12s, color .12s;
+}
+
+.dsh-mg-toolbar button:hover:not(:disabled) {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+}
+
+.dsh-mg-toolbar button:disabled {
+  color: var(--dsw-alias-label-dimmed);
+  cursor: default;
+}
+
+.dsh-mg-groupStart {
+  display: block;
+  height: 0;
+  pointer-events: none;
+}
+
+.dsh-mg-groupHeading {
+  border-radius: var(--dsw-radius-md);
+  margin: 1px 0;
+}
+
+.dsh-mg-majorHeading {
+  position: static;
+}
+
+.dsh-mg-minorHeading {
+  position: relative;
+}
+
+.dsh-mg-majorContent {
+  margin-left: 6px;
+  padding-left: 6px;
+  border-left: 1px solid var(--dsw-alias-border-l1);
+}
+
+.dsh-mg-minorContent {
+  margin-left: 6px;
+  padding-left: 6px;
+  border-left: 1px solid var(--dsw-alias-border-l1);
+}
+
+.dsh-mg-source {
+  display: block;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  line-height: 16px;
+}
+
+.dsh-mg-triggerSource {
+  color: var(--dsw-alias-label-caption);
+  font-size: 13px;
+}
+
+.dsh-mg-groupHeading button {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  min-height: 32px;
+  padding: 4px 7px;
+  border: 0;
+  border-radius: var(--dsw-radius-md);
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 13px;
+  font-weight: 500;
+  line-height: 18px;
+  text-align: left;
+  cursor: pointer;
+  transition: background .12s;
+}
+
+.dsh-mg-groupHeading button:hover:not(:disabled) {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.dsh-mg-groupHeading button:disabled {
+  cursor: default;
+}
+
+.dsh-mg-groupHeading button:focus-visible,
+.dsh-mg-toolbar button:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--dsw-focus-ring-color, var(--dsw-alias-state-business-primary));
+}
+
+.dsh-mg-groupArrow {
+  flex: none;
+  width: 14px;
+  height: 14px;
+  color: var(--dsw-alias-label-caption);
+  transition: transform .12s;
+}
+
+.dsh-mg-groupArrowOpen {
+  transform: rotate(90deg);
+}
+
+.dsh-mg-groupName {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.dsh-mg-groupCount {
+  flex: none;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  font-weight: 400;
+  line-height: 16px;
+}
+
+.dsh-mg-currentBadge {
+  flex: none;
+  color: var(--dsw-alias-state-business-primary);
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 16px;
+}
+
+.dsh-mg-groups {
+  min-height: 0;
+}
+
+.dsh-mg-groups [hidden] {
+  display: none !important;
+}
+
+/* ── 飞出卡片：与官方原版菜单 100% 结构一致，剔除 header 伪分层与白色叠加 ── */
+.dsh-mg-flyout-subgroup-list {
+  display: flex;
+  flex-direction: column;
+}
+
+.dsh-mg-subgroup-item {
+  box-sizing: border-box;
+  border-radius: var(--dsw-radius-md);
+  width: auto;
+  min-width: 100%;
+  min-height: 34px;
+  color: var(--dsw-alias-label-primary);
+  text-align: left;
+  cursor: pointer;
+  background: 0 0;
+  border: none;
+  outline: none;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 7px;
+  display: flex;
+  font: inherit;
+  font-size: 13px;
+  line-height: 18px;
+  transition: background .12s;
+}
+
+.dsh-mg-subgroup-item:hover,
+.dsh-mg-subgroup-item[data-active="true"] {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.dsh-mg-subgroup-name {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.dsh-mg-subgroup-count {
+  flex: none;
+  font-size: 11px;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+.dsh-mg-subgroup-arrow {
+  flex: none;
+  color: var(--dsw-alias-menu-icon, var(--dsw-alias-label-caption));
+}
+
+.dsh-mg-active-heading {
+  background: var(--dsw-alias-interactive-bg-hover) !important;
+}
+
+/* ── 底部模式切换：原生轻量化，无突兀高饱和蓝块 ── */
+.dsh-mg-modebar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 4px 6px 2px;
+  margin-top: 3px;
+  border-top: 1px solid var(--dsw-alias-border-l1);
+  font-size: 11px;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+.dsh-mg-mode-btn {
+  border: 0;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  font-size: 11px;
+  padding: 2px 6px;
+  border-radius: var(--dsw-radius-sm);
+  cursor: pointer;
+  transition: background .12s, color .12s;
+}
+
+.dsh-mg-mode-btn:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+}
+
+.dsh-mg-mode-btn[data-active="true"] {
+  background: var(--dsw-alias-interactive-bg-active, rgba(255, 255, 255, 0.1));
+  color: var(--dsw-alias-label-primary);
+  font-weight: 500;
+}
+
+@media (pointer: coarse) {
+  .dsh-mg-groupHeading button { min-height: 36px; }
+  .dsh-mg-toolbar button { height: 26px; }
+  .dsh-mg-mode-btn { min-height: 24px; padding: 2px 8px; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .dsh-mg-groupArrow { transition: none; }
+}
+