dsh-plugin-syncup 0.0.0-stage → 4.0.0

package/lib/manifest.js

@@ -0,0 +1,272 @@
+import { compareVersions, formatIso, isLocalSpec, isPortableSpec, isRecord } from './spec.js'
+
+export const MANIFEST_SCHEMA_VERSION = 1
+export const MANIFEST_GENERATOR = 'dsh-plugin-syncup'
+
+const MAX_BUNDLES_PER_HOST = 2000
+
+export function emptyManifest(now = new Date().toISOString()) {
+  return {
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    generatedBy: MANIFEST_GENERATOR,
+    updatedAt: now,
+    hosts: {},
+  }
+}
+
+function normalizePackageName(value) {
+  if (typeof value !== 'string') return ''
+  const name = value.trim()
+  if (name === '' || name.length > 214) return ''
+  if (!/^(?:@[^/\s]+\/)?[^/\s]+$/.test(name)) return ''
+  return name
+}
+
+function normalizeSpec(value) {
+  if (typeof value !== 'string') return ''
+  const spec = value.trim()
+  return isPortableSpec(spec) ? spec : ''
+}
+
+function normalizeBundle(value) {
+  if (!isRecord(value)) return null
+  const name = normalizePackageName(value.name)
+  if (name === '') return null
+  const version = typeof value.version === 'string' ? value.version.trim() : ''
+  const spec = normalizeSpec(value.spec) || (version === '' ? '' : normalizeSpec(`${name}@${version}`))
+  if (spec === '') return null
+  return {
+    name,
+    spec,
+    version,
+    enabled: value.enabled !== false,
+    ...(typeof value.source === 'string' && value.source.trim() !== ''
+      ? { source: value.source.trim() }
+      : {}),
+  }
+}
+
+export function normalizeHostEntry(value, hostId) {
+  if (!isRecord(value)) return null
+  if (['__proto__', 'constructor', 'prototype'].includes(hostId)) return null
+  const bundles = []
+  const seen = new Set()
+  if (Array.isArray(value.bundles)) {
+    for (const rawBundle of value.bundles) {
+      const bundle = normalizeBundle(rawBundle)
+      if (bundle === null || seen.has(bundle.name)) continue
+      bundles.push(bundle)
+      seen.add(bundle.name)
+      if (bundles.length >= MAX_BUNDLES_PER_HOST) break
+    }
+  }
+  bundles.sort((left, right) => left.name.localeCompare(right.name))
+  return {
+    hostId: typeof value.hostId === 'string' && value.hostId.trim() !== '' ? value.hostId.trim() : hostId,
+    updatedAt: formatIso(value.updatedAt),
+    ...(typeof value.dshVersion === 'string' && value.dshVersion.trim() !== ''
+      ? { dshVersion: value.dshVersion.trim() }
+      : {}),
+    ...(typeof value.profile === 'string' && value.profile.trim() !== ''
+      ? { profile: value.profile.trim() }
+      : {}),
+    ...(typeof value.platform === 'string' && value.platform.trim() !== ''
+      ? { platform: value.platform.trim() }
+      : {}),
+    bundles,
+  }
+}
+
+export function normalizeManifest(value, { source = 'manifest', requireShape = false } = {}) {
+  if (value === null || value === undefined) return emptyManifest()
+  if (!isRecord(value)) throw new Error(`${source} must be a JSON object`)
+  if (
+    requireShape
+    && value.schemaVersion === undefined
+    && value.hosts === undefined
+    && value.generatedBy === undefined
+  ) {
+    throw new Error(`${source} does not look like a plugin-sync manifest; refusing to overwrite it`)
+  }
+  const schemaVersion = value.schemaVersion === undefined ? MANIFEST_SCHEMA_VERSION : value.schemaVersion
+  if (!Number.isInteger(schemaVersion) || schemaVersion < 1) {
+    throw new Error(`${source} has an invalid schemaVersion`)
+  }
+  if (schemaVersion > MANIFEST_SCHEMA_VERSION) {
+    throw new Error(
+      `${source} uses schemaVersion ${schemaVersion}; this plugin supports up to ${MANIFEST_SCHEMA_VERSION}`,
+    )
+  }
+  const hosts = {}
+  if (value.hosts !== undefined) {
+    if (!isRecord(value.hosts)) throw new Error(`${source}.hosts must be a JSON object`)
+    for (const [hostId, rawHost] of Object.entries(value.hosts)) {
+      const host = normalizeHostEntry(rawHost, hostId)
+      if (host !== null) hosts[hostId] = host
+    }
+  }
+  return {
+    ...value,
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    generatedBy: typeof value.generatedBy === 'string' ? value.generatedBy : MANIFEST_GENERATOR,
+    updatedAt: formatIso(value.updatedAt),
+    hosts,
+  }
+}
+
+export function pickInstallSpec(bundle) {
+  if (!isRecord(bundle)) return ''
+  const target = isRecord(bundle.installTarget) ? bundle.installTarget.spec : undefined
+  if (typeof target === 'string' && isPortableSpec(target)) return target.trim()
+  const source = typeof bundle.source === 'string' ? bundle.source.trim() : ''
+  if (source !== '') {
+    if (isLocalSpec(source)) return ''
+    if (/^(?:github:|git\+|https?:|npm:)/i.test(source) || /^git@[^:\s]+:[^ \t]+$/.test(source)) return source
+    if (typeof bundle.version === 'string' && bundle.version.trim() !== '') {
+      return `${bundle.name}@${bundle.version.trim()}`
+    }
+    if (isPortableSpec(source)) return source
+  }
+  if (typeof bundle.version === 'string' && bundle.version.trim() !== '') {
+    return `${bundle.name}@${bundle.version.trim()}`
+  }
+  return ''
+}
+
+export function localHostEntry(bundles, {
+  hostId,
+  profile = '',
+  platform = process.platform,
+  now = new Date().toISOString(),
+  exclude = [],
+} = {}) {
+  const excluded = new Set(exclude)
+  const entries = []
+  const seen = new Set()
+  for (const bundle of Array.isArray(bundles) ? bundles : []) {
+    if (!isRecord(bundle) || typeof bundle.name !== 'string') continue
+    if (bundle.availability !== 'profile') continue
+    if (bundle.installed !== true) continue
+    if (bundle.removable === false) continue
+    if (excluded.has(bundle.name) || seen.has(bundle.name)) continue
+    const spec = pickInstallSpec(bundle)
+    if (!isPortableSpec(spec)) continue
+    seen.add(bundle.name)
+    entries.push({
+      name: bundle.name,
+      spec,
+      version: typeof bundle.version === 'string' ? bundle.version : '',
+      enabled: bundle.enabled !== false,
+      ...(typeof bundle.source === 'string' && bundle.source.trim() !== ''
+        ? { source: bundle.source.trim() }
+        : {}),
+    })
+    if (entries.length >= MAX_BUNDLES_PER_HOST) break
+  }
+  entries.sort((left, right) => left.name.localeCompare(right.name))
+  const dshVersion = (Array.isArray(bundles) ? bundles : []).find(
+    (bundle) => isRecord(bundle) && bundle.name === '@deepseek-ai/dsh-base' && typeof bundle.version === 'string',
+  )?.version
+  return {
+    hostId,
+    updatedAt: formatIso(now),
+    ...(typeof dshVersion === 'string' && dshVersion !== '' ? { dshVersion } : {}),
+    ...(profile !== '' ? { profile } : {}),
+    platform,
+    bundles: entries,
+  }
+}
+
+export function mergeHost(manifest, hostId, hostEntry, now = new Date().toISOString()) {
+  return {
+    ...manifest,
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    generatedBy: MANIFEST_GENERATOR,
+    updatedAt: formatIso(now),
+    lastWriter: hostId,
+    hosts: {
+      ...manifest.hosts,
+      [hostId]: hostEntry,
+    },
+  }
+}
+
+function candidateOrder(left, right) {
+  const versionCompared = compareVersions(left.version, right.version)
+  if (versionCompared !== 0) return -versionCompared
+  return new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime()
+}
+
+export function desiredBundles(manifest, {
+  includeDisabled = false,
+  exclude = [],
+  excludeHosts = [],
+} = {}) {
+  const excluded = new Set(exclude)
+  const ignoredHosts = new Set(excludeHosts)
+  const groups = new Map()
+  for (const [hostId, host] of Object.entries(manifest.hosts ?? {})) {
+    if (ignoredHosts.has(hostId)) continue
+    for (const bundle of host.bundles ?? []) {
+      if (excluded.has(bundle.name)) continue
+      let group = groups.get(bundle.name)
+      if (group === undefined) {
+        group = []
+        groups.set(bundle.name, group)
+      }
+      group.push({
+        ...bundle,
+        hostId,
+        hostUpdatedAt: host.updatedAt,
+      })
+    }
+  }
+  const desired = []
+  for (const [name, candidates] of groups) {
+    const enabled = candidates.some((candidate) => candidate.enabled !== false)
+    if (!enabled && !includeDisabled) continue
+    candidates.sort(candidateOrder)
+    const best = candidates[0]
+    const variants = candidates.map((candidate) => ({
+      hostId: candidate.hostId,
+      spec: candidate.spec,
+      version: candidate.version,
+      enabled: candidate.enabled !== false,
+      updatedAt: candidate.hostUpdatedAt,
+    }))
+    const distinctVariants = new Set(variants.map((variant) => `${variant.spec}\u0000${variant.version}`))
+    desired.push({
+      name,
+      spec: best.spec,
+      version: best.version,
+      enabled,
+      hostId: best.hostId,
+      hostUpdatedAt: best.hostUpdatedAt,
+      hosts: [...new Set(candidates.map((candidate) => candidate.hostId))].sort(),
+      variants,
+      hostConflict: distinctVariants.size > 1,
+    })
+  }
+  desired.sort((left, right) => left.name.localeCompare(right.name))
+  return desired
+}
+
+export function summarizeManifest(manifest) {
+  const hosts = Object.values(manifest.hosts ?? {}).map((host) => ({
+    hostId: host.hostId,
+    updatedAt: host.updatedAt,
+    ...(host.dshVersion === undefined ? {} : { dshVersion: host.dshVersion }),
+    ...(host.profile === undefined ? {} : { profile: host.profile }),
+    bundles: host.bundles.length,
+    enabled: host.bundles.filter((bundle) => bundle.enabled).length,
+  }))
+  hosts.sort((left, right) => left.hostId.localeCompare(right.hostId))
+  return {
+    schemaVersion: manifest.schemaVersion,
+    generatedBy: manifest.generatedBy,
+    updatedAt: manifest.updatedAt,
+    hostCount: hosts.length,
+    bundleCount: hosts.reduce((total, host) => total + host.bundles, 0),
+    hosts,
+  }
+}

package/lib/manual.js

@@ -0,0 +1,85 @@
+import { isAbsolute, join, resolve } from 'node:path'
+import { expandHome } from './spec.js'
+
+/**
+ * Where the active profile lives on disk.
+ *
+ * DSH does not hand a plugin its profile directory, so this reconstructs the
+ * conventional `<DSH_HOME>/profiles/<profile>` layout and only reports a path it
+ * can actually build. `DSH_PROFILE_DIR` wins when the host sets it.
+ */
+export function resolveProfileDir(config = {}) {
+  const explicit = typeof config.profileDir === 'string' ? config.profileDir.trim() : ''
+  if (explicit !== '') return expandHome(explicit)
+  const home = typeof config.dshHome === 'string' && config.dshHome.trim() !== ''
+    ? expandHome(config.dshHome.trim())
+    : ''
+  const profile = typeof config.profile === 'string' ? config.profile.trim() : ''
+  if (home === '' || profile === '') return ''
+  return join(home, 'profiles', profile)
+}
+
+function quote(value) {
+  return `"${value}"`
+}
+
+/**
+ * Terminal instructions for updating a bundle that HMR refuses to unload.
+ *
+ * The command is deliberately `pnpm add` rather than a remove-then-add: with DSH
+ * closed there is no live HMR to fight, and pnpm rewrites the dependency in one
+ * step. `--config.registry` is omitted so the profile's own setting applies.
+ */
+export function manualUpdateInstructions({ name, spec, profileDir, packHome }) {
+  const target = typeof spec === 'string' && spec.trim() !== '' ? spec.trim() : name
+  const safeName = typeof name === 'string' && name !== '' ? name : target
+  const steps = []
+  const dir = typeof profileDir === 'string' ? profileDir : ''
+  const pnpm = typeof packHome === 'string' && packHome !== ''
+    ? join(packHome, 'dependencies', 'pnpm', 'bin', 'pnpm.cjs')
+    : ''
+  const node = typeof packHome === 'string' && packHome !== ''
+    ? join(packHome, 'dependencies', 'node', 'bin', 'node.exe')
+    : ''
+
+  steps.push({
+    title: 'Quit DSH completely',
+    detail: 'HMR keeps the old module loaded while DSH runs, so the update needs a closed host. Close the window and make sure no DSH process is left.',
+  })
+  steps.push({
+    title: 'Open a terminal in the profile directory',
+    detail: dir === ''
+      ? 'Open the folder that holds this profile\'s package.json.'
+      : `cd ${quote(dir)}`,
+    command: dir === '' ? '' : `cd ${quote(dir)}`,
+  })
+  steps.push({
+    title: 'Update the package',
+    detail: 'Installs the newest release into the profile and rewrites its dependency entry.',
+    command: pnpm !== '' && node !== ''
+      ? `${quote(node)} ${quote(pnpm)} add ${target}`
+      : `pnpm add ${target}`,
+  })
+  steps.push({
+    title: 'Start DSH again',
+    detail: `The new version loads on start. "${safeName}" stays installed and enabled throughout.`,
+  })
+
+  return {
+    name: safeName,
+    spec: target,
+    profileDir: dir,
+    steps,
+  }
+}
+
+/** Relative-safe display path so the page never shows a bare absolute path twice. */
+export function displayPath(value, base) {
+  if (typeof value !== 'string' || value === '') return ''
+  if (typeof base !== 'string' || base === '' || !isAbsolute(value)) return value
+  const resolved = resolve(value)
+  const resolvedBase = resolve(base)
+  return resolved.startsWith(`${resolvedBase}\\`) || resolved.startsWith(`${resolvedBase}/`)
+    ? `.${resolved.slice(resolvedBase.length)}`
+    : resolved
+}

package/lib/preview.js

@@ -0,0 +1,217 @@
+import { desiredBundles, pickInstallSpec, summarizeManifest } from './manifest.js'
+import { compareVersions } from './spec.js'
+
+const KIND_ORDER = new Map([
+  ['install', 0],
+  ['upgrade', 1],
+  ['downgrade', 2],
+  ['spec-change', 3],
+  ['enable', 4],
+  ['remote-disabled', 5],
+  ['current', 6],
+  ['local-only', 7],
+])
+
+function localInstalled(bundle) {
+  return bundle !== null
+    && typeof bundle === 'object'
+    && (bundle.installed === true || bundle.availability === 'profile')
+}
+
+function localView(bundle) {
+  if (bundle === null) return null
+  return {
+    version: typeof bundle.version === 'string' ? bundle.version : '',
+    spec: pickInstallSpec(bundle),
+    enabled: bundle.enabled !== false,
+    source: typeof bundle.source === 'string' ? bundle.source : '',
+    removable: bundle.removable !== false,
+  }
+}
+
+function uniqueVariants(item) {
+  const seen = new Set()
+  const variants = []
+  for (const variant of item.variants ?? []) {
+    const key = `${variant.hostId}\u0000${variant.spec}\u0000${variant.version}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    variants.push({
+      hostId: variant.hostId,
+      spec: variant.spec,
+      version: variant.version,
+      enabled: variant.enabled !== false,
+    })
+    if (variants.length >= 20) break
+  }
+  return variants
+}
+
+function hostConflict(item) {
+  return item.hostConflict === true
+    ? {
+        type: 'host-disagreement',
+        variants: uniqueVariants(item),
+      }
+    : null
+}
+
+export function buildPreview({
+  manifest,
+  localBundles = [],
+  hostId,
+  exclude = [],
+  now = new Date().toISOString(),
+} = {}) {
+  const remote = desiredBundles(manifest, {
+    includeDisabled: true,
+    exclude,
+    excludeHosts: hostId === undefined ? [] : [hostId],
+  })
+  const local = new Map()
+  for (const bundle of localBundles) {
+    if (bundle !== null && typeof bundle === 'object' && typeof bundle.name === 'string' && localInstalled(bundle)) {
+      local.set(bundle.name, bundle)
+    }
+  }
+  const entries = []
+  const seen = new Set()
+
+  for (const item of remote) {
+    seen.add(item.name)
+    const current = local.get(item.name) ?? null
+    const currentView = localView(current)
+    const variants = uniqueVariants(item)
+    const sourceHosts = variants.map((variant) => variant.hostId)
+    const conflictFromHosts = hostConflict(item)
+    let kind
+    let choices
+    let defaultChoice
+    let conflict = null
+
+    if (current === null) {
+      kind = item.enabled ? 'install' : 'remote-disabled'
+      choices = item.enabled ? ['remote', 'skip'] : ['skip']
+      defaultChoice = item.enabled ? 'remote' : 'skip'
+      if (item.enabled && conflictFromHosts !== null) conflict = conflictFromHosts
+    } else if (!item.enabled) {
+      kind = 'remote-disabled'
+      choices = ['local']
+      defaultChoice = 'local'
+    } else {
+      const sameSpec = currentView.spec !== '' && currentView.spec === item.spec
+      const versionOrder = compareVersions(item.version, currentView.version)
+      if (sameSpec) {
+        if (currentView.enabled === false) {
+          kind = 'enable'
+          choices = ['remote', 'local']
+          defaultChoice = 'local'
+          conflict = { type: 'enable-state' }
+        } else {
+          kind = 'current'
+          choices = ['local']
+          defaultChoice = 'local'
+        }
+      } else if (item.hostConflict) {
+        kind = versionOrder > 0 ? 'upgrade' : versionOrder < 0 ? 'downgrade' : 'spec-change'
+        choices = ['remote', 'local', 'skip']
+        defaultChoice = versionOrder > 0 ? 'remote' : 'local'
+        conflict = conflictFromHosts
+      } else if (versionOrder > 0) {
+        kind = 'upgrade'
+        choices = ['remote', 'local']
+        defaultChoice = 'remote'
+      } else if (versionOrder < 0) {
+        kind = 'downgrade'
+        choices = ['remote', 'local', 'skip']
+        defaultChoice = 'local'
+        conflict = { type: 'downgrade' }
+      } else {
+        kind = 'spec-change'
+        choices = ['remote', 'local', 'skip']
+        defaultChoice = 'local'
+        conflict = { type: 'spec-change' }
+      }
+    }
+
+    entries.push({
+      id: item.name,
+      name: item.name,
+      kind,
+      local: currentView,
+      remote: {
+        spec: item.spec,
+        version: item.version,
+        enabled: item.enabled,
+        hosts: sourceHosts,
+        variants,
+      },
+      conflict,
+      choices,
+      defaultChoice,
+    })
+  }
+
+  for (const [name, bundle] of local) {
+    if (seen.has(name)) continue
+    const view = localView(bundle)
+    const removable = view.removable === true
+    entries.push({
+      id: name,
+      name,
+      kind: 'local-only',
+      local: view,
+      remote: null,
+      conflict: null,
+      choices: removable ? ['local', 'remove'] : ['local'],
+      defaultChoice: 'local',
+    })
+  }
+
+  entries.sort((left, right) => {
+    const kindOrder = (KIND_ORDER.get(left.kind) ?? 99) - (KIND_ORDER.get(right.kind) ?? 99)
+    if (kindOrder !== 0) return kindOrder
+    return left.name.localeCompare(right.name)
+  })
+
+  const conflicts = entries.filter((entry) => entry.conflict !== null)
+  const counts = {
+    entries: entries.length,
+    conflicts: conflicts.length,
+    install: entries.filter((entry) => entry.kind === 'install').length,
+    upgrade: entries.filter((entry) => entry.kind === 'upgrade').length,
+    downgrade: entries.filter((entry) => entry.kind === 'downgrade').length,
+    specChange: entries.filter((entry) => entry.kind === 'spec-change').length,
+    enable: entries.filter((entry) => entry.kind === 'enable').length,
+    localOnly: entries.filter((entry) => entry.kind === 'local-only').length,
+    removable: entries.filter((entry) => entry.kind === 'local-only' && entry.choices.includes('remove')).length,
+    actionable: entries.filter((entry) => entry.defaultChoice === 'remote').length,
+  }
+  const remoteSummary = summarizeManifest(manifest)
+  return {
+    generatedAt: now,
+    remote: {
+      updatedAt: remoteSummary.updatedAt,
+      hostCount: remoteSummary.hostCount,
+      bundleCount: remoteSummary.bundleCount,
+      hosts: remoteSummary.hosts,
+    },
+    local: {
+      profileBundles: [...local.values()].length,
+    },
+    entries,
+    conflicts,
+    counts,
+  }
+}
+
+export function selectPreviewEntries(preview, selections = {}) {
+  const chosen = []
+  for (const entry of preview.entries) {
+    const raw = selections[entry.id]
+    const choice = entry.choices.includes(raw) ? raw : entry.defaultChoice
+    if (choice !== 'remote' && choice !== 'remove') continue
+    chosen.push({ entry, choice })
+  }
+  return chosen
+}