DeepSeek Harness: 自動クリーンアップと ctx.effect()

class Context {
  private _disposables: Disposable[] = []
  
  register(disposable: Disposable) {
    this._disposables.push(disposable)
  }
  
  dispose() {
    for (const d of this._disposables.reverse()) {
      d.dispose()
    }
  }
}

import { Context } from '@deepseek-ai/cordis'

export const name = 'auto-cleanup-demo'

export function apply(ctx: Context) {
  // 以下の登録はすべて自動的にクリーンアップされる
  ctx.on('session/created', (s) => {
    ctx.logger.info(`session: ${s.id}`)
  })

  ctx.setInterval(() => {
    ctx.logger.info('tick')
  }, 10000)

  ctx.command('demo')
    .action(() => 'demo command')
}
// プラグインのアンロード時：リスナー削除 + タイマークリア + コマンド登録解除、手動コードゼロ

ctx.effect(() => {
  // クリーンアップ関数を返す
  return () => {
    // クリーンアップロジック
  }
})

import { Context } from '@deepseek-ai/cordis'

export const name = 'manual-cleanup'

export function apply(ctx: Context) {
  const connection = createExternalConnection()

  ctx.effect(() => {
    return () => {
      connection.close()
      ctx.logger.info('connection closed')
    }
  })
}

// スタイル1：クリーンアップ関数を返す（推奨）
ctx.effect(() => {
  const ws = new WebSocket('ws://localhost:8080')
  return () => ws.close()
})

// スタイル2：クリーンアップ関数の参照を渡す
const cleanup = () => { /* ... */ }
ctx.effect(cleanup)

ctx.effect(() => {
  const resource = acquireResource()
  
  return () => {
    releaseResource(resource)
  }
})

// 等価な try-finally メンタルモデル
try {
  const resource = acquireResource()
  // リソースを使用
} finally {
  releaseResource(resource)
}

export function apply(ctx: Context) {
  ctx.effect(() => {
    const db = openDatabase()
    const cache = openCache()
    
    return () => {
      cache.close()  // 依存するものを先に閉じる
      db.close()     // 次に依存元を閉じる
    }
  })
}

ctx.effect(() => {
  const conn = createConnection()
  return () => {
    try {
      conn.close()
    } catch (e) {
      ctx.logger.warn('cleanup error:', e)
    }
  }
})

export function apply(ctx: Context) {
  // ctx.setInterval を使用 — 自動クリーンアップ
  ctx.setInterval(() => {
    ctx.logger.info('heartbeat')
  }, 30000)
}

export function apply(ctx: Context) {
  const timer = setInterval(() => {
    ctx.logger.info('heartbeat')
  }, 30000)

  ctx.effect(() => {
    return () => clearInterval(timer)
  })
}

// ❌ 間違い：アンロード後も setTimeout が発火
export function apply(ctx: Context) {
  setTimeout(() => {
    ctx.logger.info('delayed action') // プラグインは既にアンロードされている可能性！
  }, 5000)
}

// ✅ 正しい：ctx.setTimeout を使用
export function apply(ctx: Context) {
  ctx.setTimeout(() => {
    ctx.logger.info('delayed action') // アンロード後は発火しない
  }, 5000)
}

import { createServer } from 'http'

export function apply(ctx: Context) {
  const server = createServer((req, res) => {
    res.end('ok')
  })

  server.listen(3456)

  ctx.effect(() => {
    return () => {
      server.close()
      ctx.logger.info('HTTP server closed')
    }
  })
}

import WebSocket from 'ws'

export function apply(ctx: Context) {
  const ws = new WebSocket('ws://localhost:8080')

  ws.on('open', () => {
    ctx.logger.info('ws connected')
  })

  ctx.effect(() => {
    return () => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.close()
      }
    }
  })
}

import { Pool } from 'pg'

export function apply(ctx: Context) {
  const pool = new Pool({
    connectionString: 'postgresql://localhost/mydb',
    max: 10
  })

  ctx.effect(() => {
    return async () => {
      await pool.end()
      ctx.logger.info('db pool closed')
    }
  })
}

export function apply(ctx: Context) {
  const emitter = getExternalEmitter()

  const handler = (data: any) => {
    ctx.logger.info('event:', data)
  }

  emitter.on('data', handler)

  ctx.effect(() => {
    return () => {
      emitter.off('data', handler)
    }
  })
}

// ❌ リーク：アンロード後もタイマーが実行
export function apply(ctx: Context) {
  setInterval(() => {
    console.log('orphan timer')
  }, 1000)
}

// ❌ データベースを先に閉じ、それに依存するキャッシュを後で閉じる
ctx.effect(() => {
  const db = openDB()
  const cache = new Cache(db)
  return () => {
    db.close()      // db を先に閉じた
    cache.close()   // キャッシュが内部的に db にアクセス → エラー
  }
})

// ❌ クリーンアップ関数がスローし、後続のクリーンアップを中断
ctx.effect(() => {
  return () => {
    throw new Error('cleanup failed')  // 他の effect が実行されない可能性
  }
})

// ❌ アンロード後に無効になる可能性のある外部変数を参照
let globalRef: SomeObject | null = new SomeObject()

export function apply(ctx: Context) {
  ctx.effect(() => {
    return () => {
      globalRef!.cleanup()  // globalRef が他のコードで null に設定されている可能性
    }
  })
}