DeepSeek Harness: 防御性编程与事故复盘

// ❌ 硬编码 API Key
const apiKey = 'sk-abc123def456'

// ❌ API Key 写入日志
ctx.logger.info(`connecting with key: ${apiKey}`)

// ❌ API Key 放在 URL 中
const url = `https://api.example.com?key=${apiKey}`

// ❌ API Key 放在错误消息中
throw new Error(`Authentication failed for key: ${apiKey}`)

// ✅ 从配置读取
export const Config = Schema.object({
  apiKey: Schema.string().required().hidden()
})

export function apply(ctx: Context) {
  const apiKey = ctx.config.apiKey
  // apiKey 只在 apply 内使用，不泄露到外部
}

// ✅ 使用环境变量
const apiKey = process.env.MY_PLUGIN_API_KEY

// ✅ 请求头传递（不进入 URL）
const response = await fetch(url, {
  headers: { 'Authorization': `Bearer ${apiKey}` }
})

// ✅ 日志中隐藏敏感信息
ctx.logger.info(`connecting to ${endpoint}`)  // 不记录 key

// ✅ 自定义日志过滤器
function sanitize(obj: any): any {
  const sanitized = { ...obj }
  if (sanitized.apiKey) sanitized.apiKey = '***'
  if (sanitized.authorization) sanitized.authorization = '***'
  return sanitized
}

ctx.logger.info('request:', sanitize(request))

export const Config = Schema.object({
  apiKey: Schema.string().required().hidden(),
  keyRotationDays: Schema.number().default(90)
})

export function apply(ctx: Context) {
  ctx.setInterval(() => {
    const age = getKeyAge()
    if (age > ctx.config.keyRotationDays * 86400000) {
      ctx.logger.warn('API key is overdue for rotation')
    }
  }, 86400000)
}

// ❌ 不验证工具结果
async execute({ path }, ctx) {
  const result = await ctx.shell.execute(`ls ${path}`)
  return result.stdout  // 可能为空或格式异常
}

// ✅ 验证工具结果
async execute({ path }, ctx) {
  const result = await ctx.shell.execute(`ls ${path}`)
  
  if (result.exitCode !== 0) {
    return {
      error: true,
      message: `ls failed: ${result.stderr}`,
      exitCode: result.exitCode
    }
  }
  
  if (!result.stdout || result.stdout.trim().length === 0) {
    return {
      error: true,
      message: 'Directory is empty or does not exist'
    }
  }
  
  const files = result.stdout.trim().split('\n')
  return { count: files.length, files }
}

// ❌ 不验证 API 响应
const data = await response.json()
return data.result

// ✅ 验证 API 响应
async function callAPI(ctx: Context, endpoint: string): Promise<any> {
  const response = await fetch(endpoint)
  
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${response.statusText}`)
  }
  
  let data: any
  try {
    data = await response.json()
  } catch {
    throw new Error('API returned invalid JSON')
  }
  
  if (!data || typeof data !== 'object') {
    throw new Error('API returned unexpected format')
  }
  
  return data
}

// ❌ 不验证用户输入
async execute({ command }, ctx) {
  return await ctx.shell.execute(command)  // 命令注入风险
}

// ✅ 验证和清理输入
async execute({ command }, ctx) {
  if (!command || typeof command !== 'string') {
    return { error: true, message: 'Invalid command' }
  }
  
  if (command.length > 1000) {
    return { error: true, message: 'Command too long' }
  }
  
  // 白名单检查
  const allowed = ['ls', 'cat', 'grep', 'wc', 'head', 'tail']
  const baseCommand = command.split(' ')[0]
  if (!allowed.includes(baseCommand)) {
    return { error: true, message: `Command not allowed: ${baseCommand}` }
  }
  
  return await ctx.shell.execute(command)
}

export function apply(ctx: Context) {
  // 所有需要清理的资源
  const resources: { close: () => void | Promise<void> }[] = []

  // 获取资源时立即注册清理
  function acquireResource<T extends { close: () => void | Promise<void> }>(
    resource: T
  ): T {
    resources.push(resource)
    return resource
  }

  // 统一清理
  ctx.effect(() => {
    return async () => {
      for (const r of resources.reverse()) {
        try {
          await r.close()
        } catch (e) {
          ctx.logger.warn('cleanup error:', e)
        }
      }
    }
  })

  // 使用
  const db = acquireResource(openDatabase())
  const ws = acquireResource(new WebSocket('ws://localhost:8080'))
}

export function apply(ctx: Context) {
  const tempFiles: string[] = []

  ctx.effect(() => {
    return async () => {
      for (const file of tempFiles.reverse()) {
        try {
          await ctx.fs.unlink(file)
        } catch {}
      }
    }
  })

  async function createTempFile(content: string): Promise<string> {
    const path = `/tmp/dsh-${Date.now()}-${Math.random().toString(36).slice(2)}`
    await ctx.fs.writeFile(path, content)
    tempFiles.push(path)
    return path
  }
}

原则 1: 副作用最小化
  → 只执行必要的操作
  → 优先只读，其次幂等写入

原则 2: 副作用可回滚
  → 写入前保存原始状态
  → 提供撤销操作

原则 3: 副作用可审计
  → 记录每次副作用的详情
  → 用户可以查看历史操作

原则 4: 副作用需审批
  → 破坏性操作必须审批
  → 非幂等操作建议审批

interface ReversibleAction {
  execute(): Promise<void>
  rollback(): Promise<void>
}

class FileEditAction implements ReversibleAction {
  private originalContent: string | null = null

  constructor(
    private path: string,
    private newContent: string,
    private ctx: Context
  ) {}

  async execute() {
    try {
      this.originalContent = await this.ctx.fs.readFile(this.path)
    } catch {
      this.originalContent = null
    }
    await this.ctx.fs.writeFile(this.path, this.newContent)
  }

  async rollback() {
    if (this.originalContent !== null) {
      await this.ctx.fs.writeFile(this.path, this.originalContent)
    } else {
      await this.ctx.fs.unlink(this.path)
    }
  }
}

const auditLog: AuditEntry[] = []

function audit(action: string, details: any, reversible: boolean) {
  auditLog.push({
    timestamp: Date.now(),
    action,
    details,
    reversible,
    user: 'agent'
  })
  ctx.emit('audit/action', { action, details, reversible })
}

// 使用
audit('file_edit', { path: 'src/app.ts', operation: 'edit' }, true)
audit('email_send', { to: 'alice@example.com' }, false)

# 事故复盘: [标题]

## 基本信息
- 日期: YYYY-MM-DD
- 影响范围: [受影响的功能/用户]
- 严重程度: P0/P1/P2
- 处理人: [姓名]

## 时间线
- HH:MM — [事件1]
- HH:MM — [事件2]
- HH:MM — [修复]

## 根因分析
[5 Whys 分析]

## 修复措施
- 短期: [立即修复]
- 长期: [预防措施]

## 教训
- [教训1]
- [教训2]

事故: Agent 删除了用户项目文件

Why 1: Agent 执行了 rm -rf /project
  → 因为工具没有路径验证

Why 2: 工具没有路径验证
  → 因为开发者没有实现白名单检查

Why 3: 开发者没有实现白名单检查
  → 因为没有安全审查流程

Why 4: 没有安全审查流程
  → 因为团队没有建立安全清单

Why 5: 团队没有建立安全清单
  → 因为缺乏安全意识培训

修复: 建立安全审计清单，所有插件发布前必须检查

# 运行安全审计
dsh audit my-plugin

# 输出
🔒 Security Audit: my-plugin

✅ No hardcoded credentials
✅ All ctx.effect() have cleanup functions
⚠️ Tool 'db_query' has no input validation
❌ API response not validated in 'fetch_data'
✅ Approval policy configured for destructive operations
⚠️ Permission 'shell.execute' may not be necessary

2 errors, 2 warnings found. Fix before publishing.