dsh-plugin-syncup 0.0.0-stage → 4.1.0

package/lib/pushplan.js

@@ -0,0 +1,200 @@
+import { compareVersions } from './spec.js'
+import { desiredBundles } from './manifest.js'
+
+function versionOf(bundle) {
+  return typeof bundle?.version === 'string' ? bundle.version.trim() : ''
+}
+
+function specOf(bundle) {
+  return typeof bundle?.spec === 'string' ? bundle.spec.trim() : ''
+}
+
+function sameEntry(left, right) {
+  return specOf(left) === specOf(right) && versionOf(left) === versionOf(right) && (left?.enabled !== false) === (right?.enabled !== false)
+}
+
+/**
+ * Compare what the Gist already holds with what this host would publish.
+ *
+ * Three cases drive the decision, per the requested policy:
+ *
+ *   - both sides have the bundle      → `conflict`: keep the newest version by
+ *     default, with an override per row;
+ *   - only the remote side has it     → `remote-only`: the user decides whether
+ *     to keep it in the Gist;
+ *   - only the local side has it      → `local-only`: push it without asking.
+ */
+export function buildPushPlan({ manifest, hostEntry, hostId, now = new Date().toISOString() }) {
+  const localBundles = Array.isArray(hostEntry?.bundles) ? hostEntry.bundles : []
+  const remote = desiredBundles(manifest, { includeDisabled: true, excludeHosts: hostId === undefined ? [] : [hostId] })
+  const remoteByName = new Map(remote.map((item) => [item.name, item]))
+  const localByName = new Map(localBundles.map((bundle) => [bundle.name, bundle]))
+
+  const entries = []
+  for (const bundle of localBundles) {
+    const counterpart = remoteByName.get(bundle.name) ?? null
+    if (counterpart === null) {
+      entries.push({
+        id: bundle.name,
+        name: bundle.name,
+        kind: 'local-only',
+        local: { spec: specOf(bundle), version: versionOf(bundle), enabled: bundle.enabled !== false },
+        remote: null,
+        choices: ['push'],
+        defaultChoice: 'push',
+        resolution: 'local',
+      })
+      continue
+    }
+    const localVersion = versionOf(bundle)
+    const remoteVersion = versionOf(counterpart)
+    const order = compareVersions(localVersion, remoteVersion)
+    if (order === 0 && sameEntry(bundle, counterpart)) {
+      entries.push({
+        id: bundle.name,
+        name: bundle.name,
+        kind: 'same',
+        local: { spec: specOf(bundle), version: localVersion, enabled: bundle.enabled !== false },
+        remote: {
+          spec: specOf(counterpart),
+          version: remoteVersion,
+          enabled: counterpart.enabled !== false,
+          hosts: counterpart.variants?.map((variant) => variant.hostId) ?? [],
+        },
+        choices: ['local'],
+        defaultChoice: 'local',
+        resolution: 'local',
+      })
+      continue
+    }
+    // The newest side wins by default; a tie keeps the local source.
+    const newest = order > 0 ? 'local' : order < 0 ? 'remote' : 'local'
+    entries.push({
+      id: bundle.name,
+      name: bundle.name,
+      kind: 'conflict',
+      local: { spec: specOf(bundle), version: localVersion, enabled: bundle.enabled !== false },
+      remote: {
+        spec: specOf(counterpart),
+        version: remoteVersion,
+        enabled: counterpart.enabled !== false,
+        hosts: counterpart.variants?.map((variant) => variant.hostId) ?? [],
+      },
+      newest,
+      choices: ['newest', 'local', 'remote'],
+      defaultChoice: 'newest',
+      resolution: newest,
+    })
+  }
+
+  for (const item of remote) {
+    if (localByName.has(item.name)) continue
+    entries.push({
+      id: item.name,
+      name: item.name,
+      kind: 'remote-only',
+      local: null,
+      remote: {
+        spec: item.spec,
+        version: item.version,
+        enabled: item.enabled !== false,
+        hosts: item.variants?.map((variant) => variant.hostId) ?? [],
+      },
+      choices: ['keep', 'drop'],
+      defaultChoice: 'keep',
+      resolution: 'keep',
+    })
+  }
+
+  entries.sort((left, right) => left.name.localeCompare(right.name))
+  const counts = {
+    entries: entries.length,
+    conflict: entries.filter((entry) => entry.kind === 'conflict').length,
+    remoteOnly: entries.filter((entry) => entry.kind === 'remote-only').length,
+    localOnly: entries.filter((entry) => entry.kind === 'local-only').length,
+    same: entries.filter((entry) => entry.kind === 'same').length,
+    needsChoice: entries.filter((entry) => entry.kind === 'remote-only').length,
+    pushed: entries.filter((entry) => entry.kind === 'local-only' || entry.kind === 'conflict' || entry.kind === 'same').length,
+  }
+  return { generatedAt: now, hostId, entries, counts }
+}
+
+function chooseConflict(entry, choice) {
+  const localNewest = entry.newest === 'local'
+  if (choice === 'local') return 'local'
+  if (choice === 'remote') return 'remote'
+  return localNewest ? 'local' : 'remote'
+}
+
+/**
+ * Turn a confirmed plan into the manifest to write.
+ *
+ * Conflict rows decide which spec/version the local host record publishes, so the
+ * Gist converges on one answer. `remote-only` rows left as `keep` are untouched;
+ * `drop` removes the bundle from every other host record.
+ */
+export function applyPushPlan({ manifest, hostEntry, hostId, plan, selections = {}, now = new Date().toISOString() }) {
+  const chosen = (entry) => {
+    const raw = selections?.[entry.id]
+    return entry.choices.includes(raw) ? raw : entry.defaultChoice
+  }
+  const dropped = new Set()
+  const published = []
+  const kept = []
+  const pushed = []
+  const conflicts = []
+
+  const bundles = []
+  for (const bundle of Array.isArray(hostEntry?.bundles) ? hostEntry.bundles : []) {
+    const entry = plan.entries.find((item) => item.id === bundle.name)
+    if (entry === undefined || entry.kind === 'local-only') {
+      bundles.push(bundle)
+      pushed.push(bundle.name)
+      continue
+    }
+    if (entry.kind === 'same') {
+      bundles.push(bundle)
+      continue
+    }
+    const side = chooseConflict(entry, chosen(entry))
+    const source = side === 'remote' ? entry.remote : entry.local
+    conflicts.push({ name: bundle.name, side, version: source?.version ?? '', spec: source?.spec ?? '' })
+    const spec = source?.spec !== undefined && source.spec !== '' ? source.spec : bundle.spec
+    bundles.push({
+      ...bundle,
+      spec,
+      version: source?.version !== undefined && source.version !== '' ? source.version : bundle.version,
+    })
+  }
+
+  for (const entry of plan.entries) {
+    if (entry.kind !== 'remote-only') continue
+    if (chosen(entry) === 'drop') dropped.add(entry.name)
+    else kept.push(entry.name)
+  }
+
+  const hosts = {}
+  for (const [id, host] of Object.entries(manifest.hosts ?? {})) {
+    if (id === hostId) continue
+    const list = Array.isArray(host.bundles) ? host.bundles.filter((bundle) => !dropped.has(bundle.name)) : []
+    hosts[id] = { ...host, bundles: list }
+  }
+  hosts[hostId] = { ...hostEntry, bundles }
+
+  return {
+    manifest: {
+      ...manifest,
+      schemaVersion: manifest.schemaVersion,
+      generatedBy: manifest.generatedBy,
+      updatedAt: now,
+      lastWriter: hostId,
+      hosts,
+    },
+    report: {
+      pushed,
+      kept,
+      dropped: [...dropped],
+      conflicts,
+    },
+  }
+}

package/lib/spec.js

@@ -0,0 +1,127 @@
+import { homedir } from 'node:os'
+import { isAbsolute, normalize, sep } from 'node:path'
+
+const REJECTED_SCHEMES = /^(?:file|link|portal|workspace|catalog):/i
+const PORTABLE_SCHEMES = /^(?:github:|git\+|https?:|npm:)/i
+const SCP_LIKE = /^git@[^:\s]+:[^ \t]+$/
+
+export function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function expandHome(value) {
+  if (typeof value !== 'string') return ''
+  const trimmed = value.trim()
+  if (trimmed === '~') return homedir()
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return normalize(`${homedir()}${sep}${trimmed.slice(2)}`)
+  }
+  return trimmed
+}
+
+export function normalizeRepo(value) {
+  if (typeof value !== 'string') return ''
+  let text = value.trim()
+  if (text === '') return ''
+  text = text.replace(/^git\+/i, '')
+  text = text.replace(/^https?:\/\/github\.com\//i, '')
+  text = text.replace(/^git@github\.com:/i, '')
+  text = text.replace(/\.git$/i, '')
+  text = text.replace(/^\/+|\/+$/g, '')
+  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(text)) return ''
+  return text
+}
+
+export function normalizeBranch(value) {
+  if (typeof value !== 'string') return 'main'
+  const branch = value.trim()
+  if (branch === '' || branch.length > 200) return 'main'
+  if (branch.startsWith('-') || branch.includes('..') || /\s/.test(branch)) return 'main'
+  return branch
+}
+
+export function normalizeManifestPath(value) {
+  if (typeof value !== 'string') return 'dsh-plugins.json'
+  const path = value.trim().replace(/\\/g, '/').replace(/^\/+|\/+$/g, '')
+  if (path === '' || path.length > 500) return 'dsh-plugins.json'
+  if (path.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')) {
+    return 'dsh-plugins.json'
+  }
+  return path
+}
+
+export function isLocalSpec(value) {
+  if (typeof value !== 'string') return false
+  const spec = value.trim()
+  if (spec === '') return false
+  if (REJECTED_SCHEMES.test(spec)) return true
+  if (spec.startsWith('/') || spec.startsWith('\\') || spec.startsWith('~')) return true
+  if (/^[A-Za-z]:[\\/]/.test(spec)) return true
+  if (spec.startsWith('./') || spec.startsWith('../') || spec.startsWith('.\\') || spec.startsWith('..\\')) {
+    return true
+  }
+  if (spec.includes('\\')) return true
+  if (spec.split('/').some((segment) => segment === '..')) return true
+  return isAbsolute(spec)
+}
+
+export function isPortableSpec(value) {
+  if (typeof value !== 'string') return false
+  const spec = value.trim()
+  if (spec === '' || spec.length > 2048) return false
+  if (isLocalSpec(spec)) return false
+  if (PORTABLE_SCHEMES.test(spec) || SCP_LIKE.test(spec)) return true
+  if (/^@[^/\s]+\/[^/\s]+(?:\/[^/\s]+)?(@[^\s]+)?$/.test(spec)) return true
+  if (/^[^/@\s][^/\s]*(?:@[^\s]+)?$/.test(spec)) return true
+  return false
+}
+
+export function parseVersion(value) {
+  if (typeof value !== 'string') return null
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value.trim())
+  if (match === null) return null
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] === undefined ? [] : match[4].split('.'),
+  }
+}
+
+function compareIdentifiers(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : null
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : null
+  if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber
+  if (leftNumber !== null) return -1
+  if (rightNumber !== null) return 1
+  return left.localeCompare(right)
+}
+
+export function compareVersions(left, right) {
+  const a = typeof left === 'object' && left !== null ? left : parseVersion(left)
+  const b = typeof right === 'object' && right !== null ? right : parseVersion(right)
+  if (a === null && b === null) return 0
+  if (a === null) return -1
+  if (b === null) return 1
+  for (const key of ['major', 'minor', 'patch']) {
+    if (a[key] !== b[key]) return a[key] - b[key]
+  }
+  if (a.prerelease.length === 0 && b.prerelease.length > 0) return 1
+  if (b.prerelease.length === 0 && a.prerelease.length > 0) return -1
+  const length = Math.max(a.prerelease.length, b.prerelease.length)
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = a.prerelease[index]
+    const rightPart = b.prerelease[index]
+    if (leftPart === undefined) return -1
+    if (rightPart === undefined) return 1
+    const compared = compareIdentifiers(leftPart, rightPart)
+    if (compared !== 0) return compared
+  }
+  return 0
+}
+
+export function formatIso(value, fallback = new Date().toISOString()) {
+  if (typeof value !== 'string') return fallback
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? fallback : date.toISOString()
+}

package/lib/state.js

@@ -0,0 +1,110 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { expandHome, formatIso, isRecord } from './spec.js'
+
+export const STATE_VERSION = 1
+const MAX_HISTORY = 20
+const MAX_RESULTS = 50
+
+export function resolveStatePath(config = {}) {
+  if (typeof config.stateFile === 'string' && config.stateFile.trim() !== '') {
+    return expandHome(config.stateFile)
+  }
+  const home = typeof config.dshHome === 'string' && config.dshHome.trim() !== ''
+    ? expandHome(config.dshHome)
+    : process.env.DSH_HOME || join(homedir(), '.dsh')
+  return join(home, 'plugin-sync', 'state.json')
+}
+
+export function emptyState(hostId = '') {
+  return {
+    version: STATE_VERSION,
+    hostId,
+    gistName: null,
+    gistId: null,
+    gistUrl: null,
+    lastPreviewAt: null,
+    lastApplyAt: null,
+    lastPushAt: null,
+    lastSyncAt: null,
+    lastPullAt: null,
+    lastRun: null,
+    remote: null,
+    lastResults: [],
+    history: [],
+    pendingUpgrades: [],
+    manualUpdates: [],
+    updatedAt: null,
+  }
+}
+
+function normalizeResult(value) {
+  if (!isRecord(value) || typeof value.name !== 'string') return null
+  return {
+    name: value.name,
+    ...(typeof value.spec === 'string' ? { spec: value.spec } : {}),
+    status: typeof value.status === 'string' ? value.status : 'unknown',
+    ...(typeof value.application === 'string' ? { application: value.application } : {}),
+    ...(typeof value.kind === 'string' ? { kind: value.kind } : {}),
+    ...(value.restartRequired === true ? { restartRequired: true } : {}),
+    ...(typeof value.error === 'string' ? { error: value.error } : {}),
+  }
+}
+
+export function normalizeState(value, hostId = '') {
+  if (!isRecord(value)) return emptyState(hostId)
+  const state = emptyState(hostId)
+  state.hostId = typeof value.hostId === 'string' && value.hostId !== '' ? value.hostId : hostId
+  if (typeof value.gistName === 'string' && value.gistName !== '') state.gistName = value.gistName
+  if (typeof value.gistId === 'string' && value.gistId !== '') state.gistId = value.gistId
+  if (typeof value.gistUrl === 'string' && value.gistUrl !== '') state.gistUrl = value.gistUrl
+  for (const key of ['lastPreviewAt', 'lastApplyAt', 'lastPushAt', 'lastSyncAt', 'lastPullAt']) {
+    if (typeof value[key] === 'string') state[key] = formatIso(value[key])
+  }
+  if (isRecord(value.lastRun)) state.lastRun = value.lastRun
+  if (isRecord(value.remote)) state.remote = value.remote
+  if (Array.isArray(value.pendingUpgrades)) {
+    state.pendingUpgrades = value.pendingUpgrades
+      .filter((item) => isRecord(item) && typeof item.name === 'string')
+      .slice(0, 20)
+  }
+  if (Array.isArray(value.manualUpdates)) {
+    state.manualUpdates = value.manualUpdates
+      .filter((item) => isRecord(item) && typeof item.name === 'string')
+      .slice(0, 20)
+  }
+  if (Array.isArray(value.lastResults)) {
+    state.lastResults = value.lastResults.map(normalizeResult).filter((item) => item !== null).slice(0, MAX_RESULTS)
+  }
+  if (Array.isArray(value.history)) {
+    state.history = value.history.filter((item) => isRecord(item)).slice(0, MAX_HISTORY)
+  }
+  if (typeof value.updatedAt === 'string') state.updatedAt = formatIso(value.updatedAt)
+  return state
+}
+
+export async function readState(path, hostId = '') {
+  try {
+    const text = await readFile(path, 'utf8')
+    return normalizeState(JSON.parse(text), hostId)
+  } catch (error) {
+    if (error !== null && typeof error === 'object' && error.code === 'ENOENT') return emptyState(hostId)
+    return {
+      ...emptyState(hostId),
+      loadError: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+export async function writeState(path, state) {
+  const normalized = normalizeState({
+    ...state,
+    updatedAt: new Date().toISOString(),
+    lastResults: Array.isArray(state.lastResults) ? state.lastResults.slice(0, MAX_RESULTS) : [],
+    history: Array.isArray(state.history) ? state.history.slice(0, MAX_HISTORY) : [],
+  }, state.hostId)
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8')
+  return normalized
+}