dsh-harbor-evolution 0.7.2 → 0.7.3

package/lib/service.js

@@ -1,7 +1,10 @@
-import { access } from 'node:fs/promises'
+import { access, stat } from 'node:fs/promises'
 import path from 'node:path'
 
+import { loadModelBinding } from './candidate.js'
+
 import {
+  discoverWorkspaceConfigs,
   readComparison,
   readDashboardSnapshot,
   readDatasetPreview,
@@ -16,6 +19,7 @@ import {
   compareCandidates,
   initializeGroundTruth,
   initializeProject,
+  initializeQuickDiagnostic,
   inspectEvaluator,
   previewContext,
   readEvaluation,
@@ -25,7 +29,9 @@ import {
   snapshot,
   updateEvaluator,
   validateDataset,
+  resolveWithin,
 } from './evolution.js'
+import { createVersionChecker } from './version.js'
 
 export async function resolveEvaluatorStackPath(config, governance, explicitPath) {
   if (explicitPath) return explicitPath
@@ -49,9 +55,54 @@ export async function resolveEvaluatorStackPath(config, governance, explicitPath
 /** One Host-side boundary shared by Agent tools and the Web dashboard. */
 export class EvolutionService {
   constructor(config, metadata = {}, modelRuntime) {
-    this.config = config
+    this.config = { jobsDir: 'jobs', ...config }
     this.metadata = metadata
     this.modelRuntime = modelRuntime
+    this.versionChecker = metadata.versionChecker ?? createVersionChecker()
+    this.projectRoots = new Map()
+    this.workspaceConfigs = new Map()
+    this.activeProjectRoot = path.resolve(this.config.projectRoot)
+    this._registerProjectRoot(this.activeProjectRoot, metadata.projectRootSource ?? 'configured')
+  }
+
+  _registerProjectRoot(projectRoot, source) {
+    const resolved = path.resolve(projectRoot)
+    this.projectRoots.set(resolved, { projectRoot: resolved, source, activatedAt: new Date().toISOString() })
+    this.activeProjectRoot = resolved
+    return this.projectRoots.get(resolved)
+  }
+
+  async _refreshWorkspaces() {
+    const discovered = []
+    this.workspaceConfigs.clear()
+    for (const [identity, root] of this.projectRoots.entries()) {
+      try {
+        const details = await stat(root.projectRoot)
+        if (!details.isDirectory()) throw new Error('not a directory')
+      } catch {
+        this.projectRoots.delete(identity)
+        continue
+      }
+      const configs = await discoverWorkspaceConfigs({ ...this.config, projectRoot: root.projectRoot })
+      for (const config of configs) {
+        const value = { ...config, projectRootSource: root.source }
+        this.workspaceConfigs.set(config.workspaceId, value)
+        discovered.push(value)
+      }
+    }
+    return discovered
+  }
+
+  async _webContext(args = {}) {
+    const workspaces = await this._refreshWorkspaces()
+    const requested = String(args.workspace ?? '').trim()
+    let config = requested ? this.workspaceConfigs.get(requested) : undefined
+    if (requested && !config) throw new Error('Workspace is unavailable; reload Harbor and select an active workspace')
+    config ??= workspaces.find(item => item.projectRoot === this.activeProjectRoot && item.workspaceRoot === '.')
+      ?? workspaces.find(item => item.projectRoot === this.activeProjectRoot)
+      ?? workspaces[0]
+    if (!config) throw new Error('No Harbor workspace is available')
+    return { config, workspaces }
   }
 
   snapshot(args) {
@@ -62,8 +113,22 @@ export class EvolutionService {
     return initializeProject(this.config, args)
   }
 
+  quickDiagnostic(args) {
+    return initializeQuickDiagnostic(this.config, args)
+  }
+
+  async _resolveCandidateModel(args) {
+    const candidatePath = resolveWithin(
+      this.config.projectRoot,
+      args.candidatePath,
+      'candidatePath',
+    )
+    const pinnedBinding = await loadModelBinding(candidatePath)
+    return this.modelRuntime.resolve(args, pinnedBinding)
+  }
+
   async run(args) {
-    const candidateModelBinding = await this.modelRuntime.resolve(args)
+    const candidateModelBinding = await this._resolveCandidateModel(args)
     return runEvaluation(this.config, { ...args, candidateModelBinding }, this.modelRuntime)
   }
 
@@ -85,7 +150,7 @@ export class EvolutionService {
   }
 
   async doctor(args) {
-    const candidateModelBinding = await this.modelRuntime.resolve(args)
+    const candidateModelBinding = await this._resolveCandidateModel(args)
     const result = await runDoctor(this.config, args)
     return { ...result, candidate_model_binding: candidateModelBinding }
   }
@@ -95,54 +160,141 @@ export class EvolutionService {
   }
 
   async previewContext(args) {
-    const candidateModelBinding = await this.modelRuntime.resolve(args)
+    const candidateModelBinding = await this._resolveCandidateModel(args)
     return previewContext(this.config, { ...args, candidateModelBinding })
   }
 
-  dashboard() {
-    return readDashboardSnapshot(this.config, this.metadata)
+  async dashboard(args = {}) {
+    const { config, workspaces } = await this._webContext(args)
+    return readDashboardSnapshot(config, {
+      ...this.metadata,
+      projectRootSource: config.projectRootSource,
+      workspaces: workspaces.map(item => ({
+        id: item.workspaceId,
+        label: item.workspaceLabel,
+        root: item.workspaceRoot,
+        projectRoot: item.projectRoot,
+        jobsDir: item.jobsDir,
+        stackPath: item.stackPath,
+        source: item.projectRootSource,
+      })),
+    }, args)
+  }
+
+  async version(args = {}) {
+    let config = this.config
+    if (args.workspace) ({ config } = await this._webContext(args))
+    else {
+      try { ({ config } = await this._webContext(args)) } catch {}
+    }
+    return this.versionChecker({
+      currentVersion: this.metadata.pluginVersion ?? 'development',
+      projectRoot: config.projectRoot,
+      refresh: args.refresh === true || args.refresh === 'true',
+    })
+  }
+
+  async modelBinding() {
+    const binding = await this.modelRuntime.currentBinding()
+    return {
+      schema_version: 1,
+      scope: 'new-candidate',
+      candidate_model_binding: binding,
+      transport: 'dsh-host-broker',
+      protocol: 'dsh-host-model-gateway/v1',
+      credentials: {
+        mode: 'host-broker-only',
+        note: 'The Candidate receives only a short-lived Job capability. Host OAuth and API credentials never enter the Candidate or Harbor artifacts.',
+      },
+      note: 'Write candidate_model_binding to model-binding.json before snapshotting. Later chat-model changes do not rewrite this Candidate.',
+    }
+  }
+
+  activateProjectRoot(requested, source = 'agent-session') {
+    if (!path.isAbsolute(requested)) throw new Error('projectRoot must be an absolute directory path')
+    const resolved = path.resolve(requested)
+    this._registerProjectRoot(resolved, source)
+    return {
+      projectRoot: resolved,
+      reloaded: true,
+      source,
+      scope: 'Web Workbench only; Agent tools remain isolated to each calling session working directory.',
+    }
+  }
+
+  async setProjectRoot(args) {
+    const requested = String(args?.projectRoot ?? '').trim()
+    if (!path.isAbsolute(requested)) throw new Error('projectRoot must be an absolute directory path')
+    const resolved = path.resolve(requested)
+    const details = await stat(resolved)
+    if (!details.isDirectory()) throw new Error('projectRoot must point to an existing directory')
+    return this.activateProjectRoot(resolved, 'manual')
   }
 
-  job(args) {
-    return readJobDetail(this.config, args)
+  async job(args) {
+    const { config } = await this._webContext(args)
+    return readJobDetail(config, args)
   }
 
-  trials(args) {
-    return readTrialsPage(this.config, args)
+  async trials(args) {
+    const { config } = await this._webContext(args)
+    return readTrialsPage(config, args)
   }
 
-  trial(args) {
-    return readTrialDetail(this.config, args)
+  async trial(args) {
+    const { config } = await this._webContext(args)
+    return readTrialDetail(config, args)
   }
 
-  dataset(args) {
-    return readDatasetPreview(this.config, args)
+  async dataset(args) {
+    const { config } = await this._webContext(args)
+    return readDatasetPreview(config, args)
   }
 
-  progress(args) {
-    return readJobProgress(this.config, args)
+  async progress(args) {
+    const { config } = await this._webContext(args)
+    return readJobProgress(config, args)
   }
 
-  comparison(args) {
-    return readComparison(this.config, args)
+  async comparison(args) {
+    const { config } = await this._webContext(args)
+    return readComparison(config, args)
   }
 
   async governance(args) {
-    const governance = await readEvaluatorGovernance(this.config, args)
+    const { config } = await this._webContext(args)
+    const governance = await readEvaluatorGovernance(config, args)
     try {
-      const stackPath = await resolveEvaluatorStackPath(this.config, governance, args.stackPath)
-      governance.evaluatorInterface = await inspectEvaluator(this.config, { ...args, stackPath })
-      governance.editingPolicy.browserWriteEnabled = true
-      governance.editingPolicy.stackPath = governance.evaluatorInterface.stack?.path
-      governance.editingPolicy.saveBehavior = 'Update one descriptor-authorized file with optimistic concurrency and create new Evaluator and Stack identities.'
+      const stackPath = await resolveEvaluatorStackPath(config, governance, args.stackPath)
+      const current = await inspectEvaluator(config, { ...args, stackPath })
+      const historicalEvaluator = governance.components?.evaluator
+      const identityMatches = current.stack?.id === governance.stackIdentity.id
+        && current.stack?.version === governance.stackIdentity.version
+        && current.evaluator?.evaluator_id === historicalEvaluator?.id
+        && current.evaluator?.version === historicalEvaluator?.version
+        && current.evaluator?.digest === historicalEvaluator?.digest
+      if (!identityMatches) {
+        governance.evaluatorInterface = {
+          error: 'The live Evaluator no longer matches this historical Job. Historical sources remain readable, but editing is disabled until you open a Job with the current Stack identity.',
+        }
+        governance.editingPolicy.identityMatch = false
+      } else {
+        governance.evaluatorInterface = current
+        governance.editingPolicy.browserWriteEnabled = true
+        governance.editingPolicy.identityMatch = true
+        governance.editingPolicy.stackPath = current.stack?.path
+        governance.editingPolicy.saveBehavior = 'Update one descriptor-authorized file with optimistic concurrency and create new Evaluator and Stack identities.'
+      }
     } catch (error) {
       governance.evaluatorInterface = { error: error instanceof Error ? error.message : String(error) }
+      governance.editingPolicy.identityMatch = false
     }
     return governance
   }
 
-  evaluator(args) {
-    return updateEvaluator(this.config, args)
+  async evaluator(args) {
+    const config = args.workspace ? (await this._webContext(args)).config : this.config
+    return updateEvaluator(config, args)
   }
 
   evaluatorInspect(args) {
@@ -158,13 +310,15 @@ export class EvolutionService {
   }
 
   async meta(args) {
-    const governance = await readEvaluatorGovernance(this.config, args)
-    const stackPath = await resolveEvaluatorStackPath(this.config, governance, args.stackPath)
-    if (!stackPath) return readMetaEvaluation(this.config)
-    const stackDirectory = path.dirname(path.resolve(this.config.projectRoot, stackPath))
+    const { config } = await this._webContext(args)
+    const governance = await readEvaluatorGovernance(config, args)
+    const stackPath = await resolveEvaluatorStackPath(config, governance, args.stackPath)
+    if (!stackPath) return readMetaEvaluation(config, args)
+    const stackDirectory = path.dirname(path.resolve(config.projectRoot, stackPath))
     const evaluationRoot = path.dirname(stackDirectory)
-    return readMetaEvaluation(this.config, {
-      evaluationRoot: path.relative(this.config.projectRoot, evaluationRoot),
+    return readMetaEvaluation(config, {
+      ...args,
+      evaluationRoot: path.relative(config.projectRoot, evaluationRoot),
     })
   }
 }

package/lib/setup.js

@@ -5,14 +5,14 @@ import process from 'node:process'
 import { fileURLToPath } from 'node:url'
 
 import { runProcess } from './process.js'
-
-export const DSH_VERSION = '0.1.0-rc.6'
+import { DSH_RUNTIME_VERSION } from './runtime-identity.js'
 
 const packageJson = JSON.parse(
   await readFile(new URL('../package.json', import.meta.url), 'utf8'),
 )
 
 export const INTEGRATION_VERSION = packageJson.version
+export const DSH_VERSION = DSH_RUNTIME_VERSION
 
 function requireValue(args, index, flag) {
   const value = args[index + 1]

package/lib/version.js

@@ -0,0 +1,128 @@
+export const NPM_PACKAGE_NAME = 'dsh-harbor-evolution'
+export const NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`
+export const RELEASES_URL = 'https://github.com/istarwyh/harbor-self-evolving/releases'
+
+const DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1_000
+const DEFAULT_FAILURE_TTL_MS = 5 * 60 * 1_000
+const DEFAULT_TIMEOUT_MS = 2_500
+
+export function parseSemver(value) {
+  const match = String(value ?? '').match(/^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/)
+  if (!match) return undefined
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+  }
+}
+
+function compareIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : undefined
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : undefined
+  if (leftNumber !== undefined && rightNumber !== undefined) return Math.sign(leftNumber - rightNumber)
+  if (leftNumber !== undefined) return -1
+  if (rightNumber !== undefined) return 1
+  return left.localeCompare(right)
+}
+
+export function compareSemver(leftValue, rightValue) {
+  const left = parseSemver(leftValue)
+  const right = parseSemver(rightValue)
+  if (!left || !right) return undefined
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) return Math.sign(left[key] - right[key])
+  }
+  if (!left.prerelease.length && !right.prerelease.length) return 0
+  if (!left.prerelease.length) return 1
+  if (!right.prerelease.length) return -1
+  const length = Math.max(left.prerelease.length, right.prerelease.length)
+  for (let index = 0; index < length; index += 1) {
+    if (left.prerelease[index] === undefined) return -1
+    if (right.prerelease[index] === undefined) return 1
+    const comparison = compareIdentifier(left.prerelease[index], right.prerelease[index])
+    if (comparison) return Math.sign(comparison)
+  }
+  return 0
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", `'"'"'`)}'`
+}
+
+export function renderUpdateCommand(latestVersion, projectRoot) {
+  if (!parseSemver(latestVersion)) throw new Error('latestVersion must be a valid semantic version')
+  return `npx --yes ${NPM_PACKAGE_NAME}@${latestVersion} setup --project-root ${shellQuote(projectRoot)}`
+}
+
+function buildResult(currentVersion, latestVersion, projectRoot, checkedAt, options = {}) {
+  const comparison = compareSemver(currentVersion, latestVersion)
+  if (comparison === undefined) {
+    return { status: 'unavailable', currentVersion, checkedAt, source: options.source, stale: options.stale }
+  }
+  const updateAvailable = comparison < 0
+  return {
+    status: updateAvailable ? 'update-available' : 'up-to-date',
+    currentVersion,
+    latestVersion,
+    checkedAt,
+    source: options.source,
+    stale: options.stale,
+    releaseUrl: updateAvailable ? `${RELEASES_URL}/tag/v${latestVersion}` : RELEASES_URL,
+    command: updateAvailable ? renderUpdateCommand(latestVersion, projectRoot) : undefined,
+  }
+}
+
+export function createVersionChecker(options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+  const now = options.now ?? Date.now
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS
+  const failureTtlMs = options.failureTtlMs ?? DEFAULT_FAILURE_TTL_MS
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  let successful
+  let failedAt = 0
+
+  return async function checkVersion({ currentVersion, projectRoot, refresh = false }) {
+    const checkedAt = new Date(now()).toISOString()
+    if (!refresh && successful && now() < successful.expiresAt) {
+      return buildResult(currentVersion, successful.latestVersion, projectRoot, successful.checkedAt, { source: 'cache' })
+    }
+    if (!refresh && !successful && failedAt && now() - failedAt < failureTtlMs) {
+      return { status: 'unavailable', currentVersion, checkedAt, source: 'cache' }
+    }
+    if (typeof fetchImpl !== 'function') {
+      failedAt = now()
+      return { status: 'unavailable', currentVersion, checkedAt, source: 'host' }
+    }
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), timeoutMs)
+    try {
+      const response = await fetchImpl(NPM_LATEST_URL, {
+        headers: { accept: 'application/json' },
+        redirect: 'error',
+        signal: controller.signal,
+      })
+      if (!response.ok) throw new Error('registry request failed')
+      const manifest = await response.json()
+      if (manifest?.name !== NPM_PACKAGE_NAME || !parseSemver(manifest.version)) {
+        throw new Error('registry response is invalid')
+      }
+      successful = {
+        latestVersion: manifest.version,
+        checkedAt,
+        expiresAt: now() + cacheTtlMs,
+      }
+      failedAt = 0
+      return buildResult(currentVersion, successful.latestVersion, projectRoot, checkedAt, { source: 'registry' })
+    } catch {
+      failedAt = now()
+      if (successful) {
+        return buildResult(currentVersion, successful.latestVersion, projectRoot, successful.checkedAt, { source: 'cache', stale: true })
+      }
+      return { status: 'unavailable', currentVersion, checkedAt, source: 'registry' }
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+}

package/lib/web.js

@@ -8,6 +8,8 @@ export const COMPARE_ROUTE = '/_dsh/harbor-evolution/compare'
 export const GOVERNANCE_ROUTE = '/_dsh/harbor-evolution/governance'
 export const EVALUATOR_ROUTE = '/_dsh/harbor-evolution/evaluator'
 export const META_ROUTE = '/_dsh/harbor-evolution/meta'
+export const PROJECT_ROOT_ROUTE = '/_dsh/harbor-evolution/project-root'
+export const VERSION_ROUTE = '/_dsh/harbor-evolution/version'
 const MAX_MUTATION_BYTES = 256 * 1024
 
 function sendJson(response, status, body) {
@@ -64,7 +66,7 @@ export function createApiHandler(load, code = 'request-failed') {
 }
 
 export function createDashboardHandler(service) {
-  return createApiHandler(() => service.dashboard(), 'dashboard-unavailable')
+  return createApiHandler(args => service.dashboard(args), 'dashboard-unavailable')
 }
 
 export function createMutationHandler(update, code = 'update-failed') {
@@ -116,6 +118,8 @@ export function installDashboardWeb(ctx, service) {
       [GOVERNANCE_ROUTE, createApiHandler(args => service.governance(args), 'governance-unavailable')],
       [EVALUATOR_ROUTE, createMutationHandler(args => service.evaluator(args), 'evaluator-update-failed')],
       [META_ROUTE, createApiHandler(args => service.meta(args), 'meta-evaluation-unavailable')],
+      [VERSION_ROUTE, createApiHandler(args => service.version(args), 'version-check-unavailable')],
+      [PROJECT_ROOT_ROUTE, createMutationHandler(args => service.setProjectRoot(args), 'project-root-update-failed')],
     ]
     for (const [route, handler] of routes) {
       webCtx.effect(() => webCtx.webServer.register({ kind: 'exact', path: route, handler }), `harbor-evolution: ${route}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-harbor-evolution",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "DeepSeek Harness plugin and bundled Skill for safely evolving Cordis Candidates with Harbor.",
   "type": "module",
   "main": "index.js",
@@ -48,9 +48,14 @@
       "platform": "web"
     }
   },
+  "harborEvolution": {
+    "runtimePolicy": "follow-latest",
+    "dshRuntimeVersion": "latest",
+    "candidateAcpPackage": "@deepseek-ai/dsh-acp-demo@latest"
+  },
   "peerDependencies": {
-    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-skill": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.6"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "3.18.1"