第十七章：Self-Modification 扩展

// 来自 packages/extensions/cordis-host-runner/src/inspect-registry.ts
class CordisInspectRegistryService {
  /** 注册检查器 */
  register(inspector: CordisInspector): Disposable {
    this.inspectors.set(inspector.id, inspector)
    
    return () => {
      this.inspectors.delete(inspector.id)
    }
  }
  
  /** 查询插件信息 */
  query(pluginId: string): PluginInfo | undefined {
    return this.inspectors.get(pluginId)?.info()
  }
  
  /** 列出所有插件 */
  list(): PluginInfo[] {
    return Array.from(this.inspectors.values()).map(i => i.info())
  }
}

interface PluginInfo {
  /** 插件 ID */
  id: string
  /** 插件名称 */
  name: string
  /** 插件版本 */
  version: string
  /** 插件状态 */
  status: 'active' | 'inactive' | 'error'
  /** 依赖的插件 */
  dependencies: string[]
  /** 提供的服务 */
  services: string[]
  /** 注册的事件监听器 */
  eventListeners: string[]
}

// 概念性描述：Agent 可以使用的自省工具
ctx.tools.register({
  name: 'inspect_plugins',
  description: 'List all loaded plugins and their status',
  parameters: {
    type: 'object',
    properties: {
      filter: { type: 'string', description: 'Filter by plugin name' }
    }
  },
  async execute(input) {
    const plugins = ctx.cordisInspector.list()
    
    if (input.filter) {
      return plugins.filter(p => p.name.includes(input.filter))
    }
    
    return plugins
  }
})

// 来自 packages/extensions/cordis-host-runner/src/index.ts（概念性）
class DynamicCordisRunnerService {
  /** 安装插件 */
  async installPlugin(plugin: PluginDefinition): Promise<void> {
    // 1. 验证插件
    await this.validatePlugin(plugin)
    
    // 2. 检查依赖
    await this.checkDependencies(plugin)
    
    // 3. 下载插件（如果是远程）
    if (plugin.remote) {
      await this.downloadPlugin(plugin)
    }
    
    // 4. 挂载插件
    await this.mountPlugin(plugin)
    
    // 5. 发送事件
    this.ctx.emit('plugin/installed', { pluginId: plugin.id })
  }
  
  /** 挂载插件 */
  private async mountPlugin(plugin: PluginDefinition): Promise<void> {
    // 动态加载插件模块
    const module = await import(plugin.entryPoint)
    
    // 注册到 Cordis
    this.ctx.plugin(module.default, plugin.config)
  }
}

interface PluginDefinition {
  /** 插件 ID */
  id: string
  /** 插件名称 */
  name: string
  /** 插件版本 */
  version: string
  /** 入口点 */
  entryPoint: string
  /** 配置 */
  config?: Record<string, unknown>
  /** 依赖 */
  dependencies?: string[]
  /** 是否为远程插件 */
  remote?: boolean
  /** 远程 URL */
  remoteUrl?: string
}

// 来自 packages/extensions/cordis-host-runner/src/index.ts（概念性）
class DynamicCordisRunnerService {
  /** 卸载插件 */
  async uninstallPlugin(pluginId: string): Promise<void> {
    // 1. 检查是否有其他插件依赖
    const dependents = this.getDependents(pluginId)
    if (dependents.length > 0) {
      throw new Error(`Cannot uninstall plugin ${pluginId}: depended on by ${dependents.join(', ')}`)
    }
    
    // 2. 卸载插件
    await this.unmountPlugin(pluginId)
    
    // 3. 清理资源
    await this.cleanupPlugin(pluginId)
    
    // 4. 发送事件
    this.ctx.emit('plugin/uninstalled', { pluginId })
  }
  
  /** 卸载插件 */
  private async unmountPlugin(pluginId: string): Promise<void> {
    // 获取插件的 disposer
    const disposer = this.pluginDisposers.get(pluginId)
    if (disposer) {
      await disposer()
      this.pluginDisposers.delete(pluginId)
    }
  }
}

// 来自 vendor/hmr/src/index.ts（概念性）
class HmrService {
  /** 监听文件变化 */
  watchFiles(directories: string[]): void {
    for (const dir of directories) {
      const watcher = chokidar.watch(dir, {
        ignoreInitial: true,
        ignored: /node_modules/
      })
      
      watcher.on('change', (path) => {
        this.handleFileChange(path)
      })
    }
  }
  
  /** 处理文件变化 */
  private async handleFileChange(path: string): Promise<void> {
    // 1. 找到对应的插件
    const plugin = this.findPluginByFile(path)
    if (!plugin) return
    
    // 2. 卸载旧插件
    await this.unmountPlugin(plugin.id)
    
    // 3. 重新加载插件
    const module = await import(path)
    
    // 4. 挂载新插件
    await this.mountPlugin({
      id: plugin.id,
      name: plugin.name,
      entryPoint: path,
      config: plugin.config
    })
    
    // 5. 发送事件
    this.ctx.emit('plugin/reloaded', { pluginId: plugin.id })
  }
}

// 来自 vendor/include/src/index.ts（概念性）
class IncludeService {
  /** 监听配置变化 */
  watchConfig(configPath: string): void {
    const watcher = chokidar.watch(configPath, {
      ignoreInitial: true
    })
    
    watcher.on('change', async () => {
      // 1. 重新加载配置
      const newConfig = await this.loadConfig(configPath)
      
      // 2. 应用配置变更
      await this.applyConfigChange(newConfig)
      
      // 3. 发送事件
      this.ctx.emit('config/reloaded', { path: configPath })
    })
  }
}

// 概念性描述
class SecurityChecker {
  /** 检查插件安装权限 */
  checkInstallPermission(agent: Agent, plugin: PluginDefinition): boolean {
    // 1. 检查 Agent 权限
    if (!agent.hasPermission('plugin:install')) {
      return false
    }
    
    // 2. 检查插件来源
    if (plugin.remote && !this.isTrustedSource(plugin.remoteUrl)) {
      return false
    }
    
    // 3. 检查插件签名
    if (plugin.signature && !this.verifySignature(plugin)) {
      return false
    }
    
    return true
  }
  
  /** 检查插件卸载权限 */
  checkUninstallPermission(agent: Agent, pluginId: string): boolean {
    // 1. 检查 Agent 权限
    if (!agent.hasPermission('plugin:uninstall')) {
      return false
    }
    
    // 2. 检查是否有其他插件依赖
    const dependents = this.getDependents(pluginId)
    if (dependents.length > 0) {
      return false
    }
    
    return true
  }
}

# cordis.patch.yml
- id: self-modification
  config:
    # 启用 Self-Modification
    enabled: true
    
    # 权限控制
    permissions:
      install: true
      uninstall: true
      reload: true
    
    # 安全限制
    security:
      requireSignature: true
      trustedSources:
        - 'https://github.com/deepseek-harness'
        - 'https://registry.npmjs.org/@deepseek-ai'
    
    # 审计日志
    audit:
      enabled: true
      logPath: '${DSH_HOME}/audit/self-modification.log'

// Agent 根据任务需要动态安装插件
async function handleComplexTask(agent: Agent, task: string): Promise<void> {
  // 1. 分析任务
  const requirements = analyzeTaskRequirements(task)
  
  // 2. 检查当前能力
  const currentPlugins = await agent.inspectPlugins()
  
  // 3. 安装缺失的能力
  for (const requirement of requirements) {
    if (!currentPlugins.some(p => p.provides.includes(requirement))) {
      await agent.installPlugin({
        id: `plugin-${requirement}`,
        name: `Plugin for ${requirement}`,
        entryPoint: `./plugins/${requirement}.js`
      })
    }
  }
  
  // 4. 执行任务
  await agent.execute(task)
}

// Agent 根据环境调整配置
async function adaptToEnvironment(agent: Agent): Promise<void> {
  // 1. 检测环境
  const environment = await agent.detectEnvironment()
  
  // 2. 调整配置
  if (environment === 'production') {
    await agent.updatePluginConfig('logging', { level: 'warn' })
    await agent.updatePluginConfig('security', { strictMode: true })
  } else {
    await agent.updatePluginConfig('logging', { level: 'debug' })
    await agent.updatePluginConfig('security', { strictMode: false })
  }
}