@chatcode/cco-market 1.45.1

package/src/themes.ts

@@ -0,0 +1,125 @@
+/**
+ * Theme lifecycle: classifying installed packages as themes (by the
+ * registry's theme category), live-toggling bundle-layer entries through
+ * the loader, and keeping exactly one theme active with the choice
+ * persisted across restarts.
+ */
+
+import { loadRegistry, pluginCategories } from './registry.ts'
+import { hotMount, hotUnmount, listHotMounts, writeDisabled } from './hot.ts'
+import { logEvent } from './log.ts'
+import { profileDir, readInstalled } from './profile.ts'
+import { repoOf } from './sources.ts'
+
+/** The slice of a cordis loader entry the market needs for live enable/disable. */
+export interface LoaderEntry {
+  options: { id?: string; name?: string; disabled?: boolean | null }
+  fiber?: unknown
+  update(options: { disabled: boolean | null }, create?: boolean, force?: boolean): Promise<void>
+}
+
+/** The host surface the theme manager needs (loader entries + hot-mount context). */
+export interface ThemeHost {
+  loader: { entries(): Iterable<LoaderEntry> }
+  plugin(plugin: unknown, config: unknown): { await(): Promise<unknown>; dispose(): Promise<unknown> | void }
+}
+
+/** Manages theme exclusivity for one profile. */
+export interface ThemeManager {
+  installedThemeNames(): Promise<Set<string>>
+  setEntryDisabled(name: string, disabledFlag: boolean): Promise<boolean>
+  activateTheme(name: string): Promise<boolean>
+}
+
+/**
+ * Create the theme manager. `disabledThemes` is the live, shared set of
+ * themes the user switched off — the caller owns reading it at boot and
+ * replaying it; the manager mutates and persists it on switches.
+ */
+export function createThemeManager(
+  host: ThemeHost,
+  profile: string,
+  disabledThemes: Set<string>,
+  explicitDir?: string,
+): ThemeManager {
+  const activeProfileDir = profileDir(profile, explicitDir)
+  /** Installed package names classified as themes by the registry's theme category. */
+  async function installedThemeNames(): Promise<Set<string>> {
+    const names = new Set<string>()
+    try {
+      const registry = await loadRegistry()
+      const themeEntries = registry.plugins.filter(p => pluginCategories(p).includes('theme'))
+      const themeNames = new Set(themeEntries.map(p => p.name))
+      const themeRepos = new Set(
+        themeEntries.map(p => repoOf(p.url)).filter((r): r is string => r !== null).map(r => r.toLowerCase()),
+      )
+      for (const [name, spec] of Object.entries(readInstalled(profile, activeProfileDir))) {
+        if (themeNames.has(name)) {
+          names.add(name)
+          continue
+        }
+        const match = /github:([^#\s]+)/.exec(String(spec).toLowerCase())
+        if (match !== null && themeRepos.has(match[1])) names.add(name)
+      }
+    } catch { /* registry unavailable — nothing classifies as a theme */ }
+    return names
+  }
+
+  /**
+   * Live-toggle a bundle-layer plugin through its loader entry. Bundle trees
+   * are in-memory (write is a no-op), so this never touches any file — the
+   * market persists the choice itself and replays it at boot.
+   * @returns true when a matching live entry was found and updated.
+   */
+  async function setEntryDisabled(name: string, disabledFlag: boolean): Promise<boolean> {
+    let found = false
+    for (const entry of host.loader.entries()) {
+      if (entry.options.name !== name) continue
+      // A disable can land while the entry's init is still in flight: the
+      // options flip but the finishing init brings the fiber up anyway, and a
+      // plain re-update no-ops on the empty diff. Force the update and verify
+      // the live state, retrying until reality matches the flag.
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          await entry.update({ disabled: disabledFlag ? true : null }, false, true)
+          found = true
+        } catch (error) {
+          logEvent('warn', 'toggle', `${name}: entry update failed — ${error instanceof Error ? error.message : String(error)}`)
+          break
+        }
+        const live = entry.fiber !== undefined
+        if (live !== disabledFlag) break
+        await new Promise(resolvePromise => setTimeout(resolvePromise, 200))
+      }
+      logEvent('info', 'toggle',
+        `${name} -> ${disabledFlag ? 'off' : 'on'}: fiber=${String(entry.fiber !== undefined)}`)
+    }
+    if (!found) logEvent('info', 'toggle', `${name}: no loader entry matched`)
+    return found
+  }
+
+  /**
+   * Make `name` the one active theme: deactivate every other installed theme
+   * (market hot mounts unmount; bundle-layer entries live-disable) and bring
+   * it up. The choice persists in state.json and is replayed at boot.
+   */
+  async function activateTheme(name: string): Promise<boolean> {
+    const themes = await installedThemeNames()
+    for (const other of themes) {
+      if (other === name) continue
+      if (listHotMounts().includes(other)) {
+        await hotUnmount(other)
+        disabledThemes.add(other)
+      } else if (await setEntryDisabled(other, true)) {
+        disabledThemes.add(other)
+      }
+    }
+    disabledThemes.delete(name)
+    writeDisabled(activeProfileDir, disabledThemes)
+    if (listHotMounts().includes(name)) return true
+    if (await setEntryDisabled(name, false)) return true
+    return (await hotMount(host, activeProfileDir, name)).ok
+  }
+
+  return { installedThemeNames, setEntryDisabled, activateTheme }
+}

package/src/trial.ts

@@ -0,0 +1,156 @@
+/**
+ * Trial validation for composition changes — issue #98 (phase 3), the
+ * "trial boot" half of #19 reduced to what is safe and offline: before any
+ * bundle-order or preset change is written to the profile, replay the
+ * composition with the CANDIDATE order using the same entry-list machinery
+ * the real boot uses (src/check.ts's buildBundleLayers + composeLayers), and
+ * refuse the change when the composed tree would fail to boot (duplicate
+ * loader entry ids, unresolvable bundle layers, unparseable patches).
+ *
+ * No process, no network, no writes to the profile: the real profile is only
+ * read; if the candidate is bad, the failure is reported and nothing is
+ * applied (the caller then skips the write-back entirely).
+ *
+ * Issue #125 review: the CURRENT composition is replayed alongside the
+ * candidate, so the response also carries a current-vs-candidate diff
+ * (overrides / orphans / duplicates the reorder introduces) — not just
+ * whether it boots.
+ *
+ * Bundle resolution is deliberately SHARED with the check report
+ * (check.ts's buildBundleLayers): the dsh installation anchor first, then
+ * Node's module search from the profile (workspace-root hoisting) — so the
+ * trial can never disagree with the diagnostics about what a bundle is or
+ * where it lives, and official bundles resolve even when they are only
+ * hoisted to the workspace root.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import {
+  buildBundleLayers, composeLayers, findDshInstallDir, parsePatchFile,
+  type DuplicateId, type LayerInput, type OrphanRow, type OverrideRow,
+} from './check.ts'
+import { resolveDshHome } from './home-paths.ts'
+import { mergeOrder, readBundleStack } from './order.ts'
+
+export interface TrialIssue {
+  layer: string
+  message: string
+}
+
+/** Current-vs-candidate composition diff (issue #125 review). */
+export interface TrialDiff {
+  /** Override relationships introduced by the candidate (not present in the current composition). */
+  overrides: OverrideRow[]
+  /** Orphan rows introduced by the candidate. */
+  orphans: OrphanRow[]
+  /** Duplicate loader entry ids introduced by the candidate. */
+  duplicates: DuplicateId[]
+}
+
+export interface TrialResult {
+  ok: boolean
+  errors: TrialIssue[]
+  warnings: TrialIssue[]
+  duplicates: DuplicateId[]
+  /** The composed loader rows under the candidate order. */
+  rows: { id: string; layer: string }[]
+  /** What the reorder would change vs the current composition (issue #125 review). */
+  diff: TrialDiff
+}
+
+/**
+ * Replay the profile composition with `newCommunityOrder` (the candidate
+ * community-bundle order; official bundles keep their exact positions) and
+ * report anything that would break the boot. Pure read.
+ */
+export function trialValidate(
+  profileDir: string,
+  newCommunityOrder: string[],
+  options: { dshInstallDir?: string | null; homeDir?: string } = {},
+): TrialResult {
+  const errors: TrialIssue[] = []
+  const warnings: TrialIssue[] = []
+  const current = readBundleStack(profileDir)
+  // Same merge the apply path uses (order.ts mergeOrder): the trial replays
+  // EXACTLY the stack a successful apply would write.
+  const merged = mergeOrder(current.bundles, newCommunityOrder)
+  if (!merged.ok) {
+    return {
+      ok: false, errors: [{ layer: '(order)', message: merged.error }], warnings,
+      duplicates: [], rows: [],
+      diff: { overrides: [], orphans: [], duplicates: [] },
+    }
+  }
+  const candidate = merged.bundles
+
+  // Shared bundle-layer build — identical resolution to analyzeProfile
+  // (dsh install anchor first, then Node module search from the profile).
+  let specs: Record<string, string> = {}
+  try {
+    const manifest = JSON.parse(readFileSync(join(profileDir, 'package.json'), 'utf8')) as {
+      dependencies?: Record<string, string>
+    }
+    specs = manifest.dependencies ?? {}
+  } catch { /* specs stay empty — sources read as '(not a direct dependency)' */ }
+  const dshInstall = options.dshInstallDir !== undefined ? options.dshInstallDir : findDshInstallDir()
+
+  // Same user/home patch layers as the boot (and the check report) — shared
+  // by BOTH compositions.
+  const patchLayers: LayerInput[] = []
+  const userPatchPath = join(profileDir, 'cordis.patch.yml')
+  if (existsSync(userPatchPath)) {
+    const patches = parsePatchFile(userPatchPath)
+    patchLayers.push({ label: 'user-patch', kind: 'user', patches: patches ?? [], parseError: null })
+    if (patches === null) errors.push({ layer: 'user-patch', message: 'cordis.patch.yml is not a valid entry list / cordis.patch.yml 不是合法的条目列表' })
+  }
+  const home = resolveDshHome(options.homeDir)
+  const homePatchPath = join(home, 'cordis.patch.yml')
+  if (existsSync(homePatchPath)) {
+    const patches = parsePatchFile(homePatchPath)
+    patchLayers.push({ label: 'home-patch', kind: 'home', patches: patches ?? [], parseError: null })
+    if (patches === null) errors.push({ layer: 'home-patch', message: 'home cordis.patch.yml is not a valid entry list / 全局 cordis.patch.yml 不是合法的条目列表' })
+  }
+
+  /** Compose the loader tree for one bundle order (current or candidate). */
+  const compose = (bundleOrder: string[]): { built: ReturnType<typeof buildBundleLayers>; composed: ReturnType<typeof composeLayers> } => {
+    const built = buildBundleLayers(profileDir, bundleOrder, specs, dshInstall)
+    return { built, composed: composeLayers([...built.layers, ...patchLayers]) }
+  }
+
+  const currentState = compose(current.bundles)
+  const candidateState = compose(candidate)
+  const composed = candidateState.composed
+
+  for (const bundle of candidateState.built.bundles) {
+    if (bundle.error !== null) errors.push({ layer: bundle.name, message: bundle.error })
+    if (bundle.parseError !== null) errors.push({ layer: bundle.name, message: bundle.parseError })
+  }
+  for (const dup of composed.duplicates) {
+    errors.push({ layer: dup.layers.join(' / '), message: `duplicate loader entry id ${JSON.stringify(dup.id)} (${dup.count} rows) / 重复的 loader 条目 id ${JSON.stringify(dup.id)}` })
+  }
+  for (const orphan of composed.orphans) {
+    warnings.push({ layer: orphan.layer, message: `${orphan.id}: ${orphan.reason}` })
+  }
+
+  // Issue #125 review: what does the reorder CHANGE? Compare the candidate
+  // composition against the current one — only candidate-introduced
+  // overrides / orphans / duplicates are reported.
+  const currentDupIds = new Set(currentState.composed.duplicates.map(d => d.id))
+  const sameOverride = (a: OverrideRow, b: OverrideRow): boolean =>
+    a.id === b.id && a.layer === b.layer && a.overriddenLayers.join('\u0000') === b.overriddenLayers.join('\u0000')
+  const diff: TrialDiff = {
+    overrides: composed.overrides.filter(o => !currentState.composed.overrides.some(c => sameOverride(o, c))),
+    orphans: composed.orphans.filter(o => !currentState.composed.orphans.some(c => c.id === o.id && c.layer === o.layer)),
+    duplicates: composed.duplicates.filter(d => !currentDupIds.has(d.id)),
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    duplicates: composed.duplicates,
+    rows: composed.rows.map(row => ({ id: row.id, layer: row.layer })),
+    diff,
+  }
+}

package/src/update-api-v1.ts

@@ -0,0 +1,277 @@
+/**
+ * Stable, versioned contract for plugin-owned update surfaces.
+ *
+ * The market UI has richer internal response shapes that evolve with its UI.
+ * Third-party plugins must not depend on those shapes, so this module owns the
+ * small JSON envelope exposed under `/dsh-market/api/v1`.
+ */
+
+import type { InstallProgress } from './dsh-cli.ts'
+
+export const UPDATE_API_V1_SCHEMA = 'dsh-market/update-api/v1' as const
+export const MAX_UPDATE_OPERATIONS_V1 = 50
+
+export type UpdateOperationState =
+  | 'queued'
+  | 'running'
+  | 'succeeded'
+  | 'failed'
+  | 'cancelled'
+  | 'rolled-back'
+
+export interface UpdateFailureV1 {
+  code: string
+  message: string
+  retryable: boolean
+}
+
+export interface UpdateOperationV1 {
+  schema: typeof UPDATE_API_V1_SCHEMA
+  operationId: string
+  kind: 'update'
+  packageName: string
+  state: UpdateOperationState
+  createdAt: number
+  startedAt: number | null
+  finishedAt: number | null
+  beforeVersion: string | null
+  installedVersion: string | null
+  progress: {
+    phase: string | null
+    done: number
+    total: number | null
+    percent: number | null
+    currentPackage: string | null
+    detail: string | null
+    downloaded: number | null
+    size: number | null
+  }
+  outcome: {
+    refreshRequired: boolean
+    restartRequired: boolean
+    rollback: {
+      available: boolean
+      state: 'unavailable' | 'available' | 'running' | 'succeeded' | 'failed'
+      detail: string | null
+    }
+  }
+  failure: UpdateFailureV1 | null
+}
+
+interface StoredOperation extends UpdateOperationV1 {
+  legacyRollbackId: string | null
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+}
+
+function text(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : null
+}
+
+function bool(value: unknown): boolean {
+  return value === true
+}
+
+function failureCode(status: number, body: Record<string, unknown>): string {
+  const explicit = text(body.failureCode)
+  if (explicit === 'DOWNGRADE_DETECTED' || explicit === 'RESOLVED_VERSION_MISMATCH') return explicit
+  if (body.agentsBusy === true) return 'AGENTS_RUNNING'
+  if (body.busy === true || status === 409) return 'OPERATION_BUSY'
+  if (body.stale === true && body.staleReason === 'release-age') return 'RELEASE_TOO_FRESH'
+  if (body.stale === true) return 'VERSION_UNCHANGED'
+  if (body.timedOut === true) return 'UPDATE_TIMEOUT'
+  if (status === 403) return 'UPDATE_FORBIDDEN'
+  if (status === 400) return 'UPDATE_REJECTED'
+  return 'UPDATE_FAILED'
+}
+
+function failureOf(status: number, body: Record<string, unknown>): UpdateFailureV1 {
+  const code = failureCode(status, body)
+  const message = text(body.error)
+    ?? text(body.stderr)
+    ?? text(body.stdout)
+    ?? `update failed with HTTP ${String(status)}`
+  return {
+    code,
+    message: message.slice(-1200),
+    retryable: code === 'AGENTS_RUNNING'
+      || code === 'OPERATION_BUSY'
+      || code === 'RELEASE_TOO_FRESH'
+      || code === 'VERSION_UNCHANGED'
+      || code === 'RESOLVED_VERSION_MISMATCH'
+      || code === 'UPDATE_TIMEOUT',
+  }
+}
+
+function activationState(body: Record<string, unknown>, packageName: string): string | null {
+  const activations = record(body.activation)
+  const activation = activations === null ? null : record(activations[packageName])
+  return activation === null ? null : text(activation.state)
+}
+
+function rollbackIdOf(body: Record<string, unknown>): string | null {
+  const compatibility = record(body.compatibility)
+  return compatibility === null ? null : text(compatibility.rollbackId)
+}
+
+function progressView(progress?: InstallProgress): UpdateOperationV1['progress'] {
+  if (progress === undefined) {
+    return {
+      phase: null,
+      done: 0,
+      total: null,
+      percent: null,
+      currentPackage: null,
+      detail: null,
+      downloaded: null,
+      size: null,
+    }
+  }
+  const percent = progress.total !== null && progress.total > 0
+    ? Math.min(100, Math.round(progress.done / progress.total * 100))
+    : null
+  return {
+    phase: progress.phase,
+    done: progress.done,
+    total: progress.total,
+    percent,
+    currentPackage: progress.currentPackage,
+    detail: text(progress.lastLine) ?? text(progress.error),
+    downloaded: progress.downloaded,
+    size: progress.size,
+  }
+}
+
+/** Process-local operation registry. A boot id scopes ids across restarts. */
+export class UpdateOperationStoreV1 {
+  private sequence = 0
+  private readonly operations = new Map<string, StoredOperation>()
+  private activeId: string | null = null
+
+  constructor(
+    private readonly bootId: string,
+    private readonly now: () => number = Date.now,
+    private readonly maxOperations: number = MAX_UPDATE_OPERATIONS_V1,
+  ) {}
+
+  hasActive(): boolean {
+    return this.activeId !== null
+  }
+
+  create(packageName: string, beforeVersion: string | null): UpdateOperationV1 {
+    const operationId = `${this.bootId}-update-${String(++this.sequence)}`
+    const createdAt = this.now()
+    const operation: StoredOperation = {
+      schema: UPDATE_API_V1_SCHEMA,
+      operationId,
+      kind: 'update',
+      packageName,
+      state: 'queued',
+      createdAt,
+      startedAt: null,
+      finishedAt: null,
+      beforeVersion,
+      installedVersion: beforeVersion,
+      progress: progressView(),
+      outcome: {
+        refreshRequired: false,
+        restartRequired: false,
+        rollback: { available: false, state: 'unavailable', detail: null },
+      },
+      failure: null,
+      legacyRollbackId: null,
+    }
+    this.operations.set(operationId, operation)
+    this.activeId = operationId
+    while (this.operations.size > this.maxOperations) {
+      const oldestId = this.operations.keys().next().value as string | undefined
+      if (oldestId === undefined || oldestId === this.activeId) break
+      this.operations.delete(oldestId)
+    }
+    return this.snapshot(operation)
+  }
+
+  start(operationId: string): void {
+    const operation = this.operations.get(operationId)
+    if (operation === undefined) return
+    operation.state = 'running'
+    operation.startedAt = this.now()
+    this.activeId = operationId
+  }
+
+  finish(
+    operationId: string,
+    status: number,
+    payload: unknown,
+    installedVersion: string | null,
+  ): UpdateOperationV1 | null {
+    const operation = this.operations.get(operationId)
+    if (operation === undefined) return null
+    const body = record(payload) ?? {}
+    const cancelled = bool(body.cancelled)
+    const ok = status >= 200 && status < 300 && bool(body.ok) && !cancelled
+    operation.state = cancelled ? 'cancelled' : ok ? 'succeeded' : 'failed'
+    operation.finishedAt = this.now()
+    operation.installedVersion = installedVersion
+    operation.failure = ok || cancelled ? null : failureOf(status, body)
+    const activation = activationState(body, operation.packageName)
+    operation.outcome.restartRequired = activation === 'restart'
+    operation.outcome.refreshRequired = bool(body.needsRefresh)
+      || (activation === 'live' && body.hot === true)
+    operation.legacyRollbackId = rollbackIdOf(body)
+    if (operation.legacyRollbackId !== null) {
+      operation.outcome.rollback.available = true
+      operation.outcome.rollback.state = 'available'
+    }
+    if (this.activeId === operationId) this.activeId = null
+    return this.snapshot(operation)
+  }
+
+  beginRollback(operationId: string): string | null {
+    const operation = this.operations.get(operationId)
+    if (operation?.legacyRollbackId === null || operation?.legacyRollbackId === undefined) return null
+    operation.outcome.rollback.state = 'running'
+    operation.outcome.rollback.detail = null
+    return operation.legacyRollbackId
+  }
+
+  finishRollback(
+    operationId: string,
+    status: number,
+    payload: unknown,
+    installedVersion?: string | null,
+  ): UpdateOperationV1 | null {
+    const operation = this.operations.get(operationId)
+    if (operation === undefined) return null
+    const body = record(payload) ?? {}
+    const ok = status >= 200 && status < 300 && body.rolledBack === true
+    // The rollback endpoint supplies a fresh disk read. Keep the argument
+    // optional so existing store consumers retain source compatibility.
+    if (installedVersion !== undefined) operation.installedVersion = installedVersion
+    operation.outcome.rollback.available = !ok && status !== 400
+    operation.outcome.rollback.state = ok ? 'succeeded' : 'failed'
+    operation.outcome.rollback.detail = ok ? null : text(body.error) ?? `rollback failed with HTTP ${String(status)}`
+    if (ok) {
+      operation.state = 'rolled-back'
+      operation.outcome.restartRequired = true
+    }
+    return this.snapshot(operation)
+  }
+
+  get(operationId: string, progress?: InstallProgress): UpdateOperationV1 | null {
+    const operation = this.operations.get(operationId)
+    if (operation === undefined) return null
+    const view = this.snapshot(operation)
+    if (this.activeId === operationId && operation.state === 'running') view.progress = progressView(progress)
+    return view
+  }
+
+  private snapshot(operation: StoredOperation): UpdateOperationV1 {
+    const { legacyRollbackId: _legacyRollbackId, ...view } = operation
+    return structuredClone(view)
+  }
+}