@miphamai/cli 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -45,6 +45,7 @@
     "commander": "^13.1.0",
     "ink": "^5.2.1",
     "ink-text-input": "^6.0.0",
+    "js-tiktoken": "^1.0.21",
     "react": "^18.3.1",
     "react-devtools-core": "^4.28.5",
     "yaml": "^2.9.0"

package/src/commands/keys.ts

@@ -0,0 +1,94 @@
+import type { CommandHandler } from '../ui/commands'
+import { KeyManager } from '../config/keys-manager'
+
+export const keysCmd: CommandHandler = async (_ctx, args) => {
+  const manager = new KeyManager()
+  const sub = args[0]?.toLowerCase()
+
+  // /keys rotate <provider>
+  if (sub === 'rotate') {
+    const provider = args[1]
+    if (!provider) {
+      return {
+        content: 'Usage: /keys rotate <provider>\n\nExample: /keys rotate deepseek',
+      }
+    }
+    // Interactive: prompt user to provide new key via follow-up chat message
+    return {
+      content: [
+        '── Key Rotation ──',
+        '',
+        `Provider: ${provider}`,
+        '',
+        'To complete rotation, the new API key must be provided.',
+        'Type your new key in chat and the AI will handle rotation securely.',
+        '',
+        'The old key will be backed up to ~/.mipham/keys/<provider>.backup (chmod 600).',
+      ].join('\n'),
+      forwardToAI: `The user wants to rotate the API key for provider "${provider}". Ask them to provide the new key value, then:
+1. Call KeyManager.rotate("${provider}", newKey) with the provided key
+2. The new key should be stored in ~/.mipham/config.json (or appropriate config)
+3. Confirm rotation count and backup location
+4. Remind them the old key is backed up at ~/.mipham/keys/${provider}.backup`,
+    }
+  }
+
+  // /keys audit
+  if (sub === 'audit') {
+    const expired = manager.audit()
+    if (expired.length === 0) {
+      return {
+        content:
+          '── Key Audit ──\n\n✅ All keys are within the 90-day rotation window.\n\nNo expired keys found.',
+      }
+    }
+
+    const lines: string[] = [
+      '── Key Audit ──',
+      '',
+      `⚠️  ${expired.length} key(s) have exceeded the 90-day rotation threshold:`,
+      '',
+      ...expired.map(
+        (k) =>
+          `  🔴 ${k.provider.padEnd(16)} ${k.ageDays} days since last rotation (${k.lastRotated.slice(0, 10)})`,
+      ),
+      '',
+      'Rotate expired keys with: /keys rotate <provider>',
+    ]
+    return { content: lines.join('\n') }
+  }
+
+  // /keys (list)
+  const keys = manager.list()
+
+  if (keys.length === 0) {
+    return {
+      content: [
+        '── API Keys ──',
+        '',
+        'No API keys tracked yet.',
+        '',
+        'Keys are tracked in ~/.mipham/keys.json when you configure providers.',
+        'Use /keys rotate <provider> to begin tracking rotation for a provider.',
+      ].join('\n'),
+    }
+  }
+
+  const lines: string[] = [
+    '── API Keys ──',
+    '',
+    'Provider         Age     Rotations   Status',
+    '─'.repeat(55),
+    ...keys.map((k) => {
+      const status = k.expired ? '🔴 EXPIRED' : '🟢 OK'
+      return `  ${k.provider.padEnd(16)} ${String(k.ageDays).padStart(4)}d   ${String(k.rotationCount).padStart(5)}       ${status}`
+    }),
+    '',
+    `${keys.length} key(s) tracked.`,
+    '',
+    'Commands:',
+    '  /keys rotate <provider>  — rotate a key',
+    '  /keys audit             — check for expired keys',
+  ]
+  return { content: lines.join('\n') }
+}

package/src/config/keys-manager.ts

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { homedir } from 'node:os'
+
+const MIPHAM_DIR = join(homedir(), '.mipham')
+const KEYS_FILE = join(MIPHAM_DIR, 'keys.json')
+
+export interface KeyEntry {
+  createdAt: string
+  lastRotated: string
+  rotationCount: number
+  provider: string
+}
+
+export interface KeyStatus {
+  provider: string
+  createdAt: string
+  lastRotated: string
+  rotationCount: number
+  ageDays: number
+  expired: boolean
+}
+
+export interface KeysData {
+  [provider: string]: KeyEntry
+}
+
+function loadKeys(): KeysData {
+  if (!existsSync(KEYS_FILE)) return {}
+  try {
+    const raw = readFileSync(KEYS_FILE, 'utf-8')
+    return JSON.parse(raw) as KeysData
+  } catch {
+    return {}
+  }
+}
+
+function saveKeys(data: KeysData): void {
+  mkdirSync(dirname(KEYS_FILE), { recursive: true })
+  const tmp = KEYS_FILE + '.tmp'
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 })
+  writeFileSync(KEYS_FILE, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 })
+  try {
+    chmodSync(KEYS_FILE, 0o600)
+  } catch {
+    // chmod on Windows is a no-op
+  }
+}
+
+function daysSince(iso: string): number {
+  const then = new Date(iso).getTime()
+  const now = Date.now()
+  return Math.floor((now - then) / (1000 * 60 * 60 * 24))
+}
+
+export class KeyManager {
+  list(): KeyStatus[] {
+    const data = loadKeys()
+    return Object.entries(data).map(([provider, entry]) => ({
+      provider,
+      createdAt: entry.createdAt,
+      lastRotated: entry.lastRotated,
+      rotationCount: entry.rotationCount,
+      ageDays: daysSince(entry.lastRotated),
+      expired: daysSince(entry.lastRotated) > 90,
+    }))
+  }
+
+  rotate(provider: string, _newKey: string): { success: boolean; message: string } {
+    const data = loadKeys()
+    const now = new Date().toISOString()
+    const existing = data[provider]
+
+    // Backup old entry if it exists
+    if (existing) {
+      const backupDir = join(MIPHAM_DIR, 'keys')
+      mkdirSync(backupDir, { recursive: true })
+      const backupPath = join(backupDir, `${provider}.backup`)
+      writeFileSync(backupPath, JSON.stringify(existing, null, 2) + '\n', { mode: 0o600 })
+      try {
+        chmodSync(backupPath, 0o600)
+      } catch {
+        // Windows
+      }
+
+      data[provider] = {
+        createdAt: existing.createdAt,
+        lastRotated: now,
+        rotationCount: existing.rotationCount + 1,
+        provider,
+      }
+    } else {
+      data[provider] = {
+        createdAt: now,
+        lastRotated: now,
+        rotationCount: 1,
+        provider,
+      }
+    }
+
+    saveKeys(data)
+    return {
+      success: true,
+      message: `Key for "${provider}" rotated (rotation #${data[provider]!.rotationCount}). Backup saved to ~/.mipham/keys/${provider}.backup`,
+    }
+  }
+
+  audit(): KeyStatus[] {
+    return this.list().filter((k) => k.expired)
+  }
+
+  getExpiryReminder(): string | null {
+    const expired = this.audit()
+    if (expired.length === 0) return null
+
+    const lines = expired.map(
+      (k) => `  - ${k.provider}: last rotated ${k.ageDays} days ago (90-day threshold exceeded)`,
+    )
+    return `⚠️  API key rotation overdue:\n${lines.join('\n')}\n\nRun /keys rotate <provider> to rotate.`
+  }
+}

package/src/core/context-compact.ts

@@ -43,7 +43,7 @@ export async function reactiveCompact(
   // Rebuild messages: summary + recent
   const summaryMsg = {
     role: 'user' as const,
-    content: `[Earlier conversation summary — ${heading}]: ${summary.slice(0, 2000)}`,
+    content: `[Earlier conversation summary — ${heading}]: ${summary.slice(0, 8000)}`,
   }
 
   context.replaceMessages([summaryMsg, ...toKeep])

package/src/core/context.ts

@@ -10,6 +10,7 @@ export type Summarizer = (messages: Message[], heading: string) => Promise<strin
 interface ContextConfig {
   maxTokens: number
   compactionThreshold: number // e.g. 0.9 → compact at 90% usage
+  contextWindow?: number // model's declared context window (for adaptive thresholds)
 }
 
 export interface CompactionStats {
@@ -53,11 +54,25 @@ export class ContextManager {
   }
   private compressionPending = false
 
-  constructor(private config: ContextConfig) {}
+  constructor(private config: ContextConfig) {
+    // Adaptive thresholds: larger context → later compaction
+    // 200K → 0.90, 500K → 0.93, 1M → 0.95
+    if (config.contextWindow && config.contextWindow > 200_000) {
+      config.compactionThreshold = Math.max(0.9, 1 - 50000 / config.contextWindow)
+    }
+  }
+
+  getCompactionThreshold(): number {
+    return this.config.compactionThreshold
+  }
 
   /** Dynamically update the max token limit (e.g., when switching models). */
-  updateMaxTokens(maxTokens: number): void {
+  updateMaxTokens(maxTokens: number, contextWindow?: number): void {
     this.config.maxTokens = maxTokens
+    if (contextWindow) {
+      this.config.contextWindow = contextWindow
+      this.config.compactionThreshold = Math.max(0.9, 1 - 50000 / contextWindow)
+    }
   }
 
   getMaxTokens(): number {
@@ -286,7 +301,12 @@ export class ContextManager {
 
     const usage = this.estimatedTokens / this.config.maxTokens
 
-    if (usage > 0.7) {
+    // Adaptive microcompact threshold: 200K→0.70, 500K→0.80, 1M→0.85
+    const microThreshold = this.config.contextWindow
+      ? Math.max(0.7, 1 - 150000 / this.config.contextWindow)
+      : 0.7
+
+    if (usage > microThreshold) {
       this.compressionPending = true
       // Schedule microcompact asynchronously (fire-and-forget)
       Promise.resolve().then(() => {

package/src/core/engine.ts

@@ -204,7 +204,7 @@ export class QueryEngine {
         .map((m) => {
           const role = m.role
           const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content)
-          return `[${role}]: ${content.slice(0, 500)}`
+          return `[${role}]: ${content.slice(0, 2000)}`
         })
         .join('\n')
 
@@ -220,7 +220,7 @@ export class QueryEngine {
             { role: 'system', content: summaryPrompt },
             { role: 'user', content: text },
           ],
-          maxTokens: 300,
+          maxTokens: 2000,
         })) {
           if (chunk.type === 'text' && chunk.content) {
             summary += chunk.content
@@ -232,7 +232,7 @@ export class QueryEngine {
         // Return a minimal summary on failure
       }
 
-      return summary.slice(0, 2000) || 'Prior conversation context omitted.'
+      return summary.slice(0, 8000) || 'Prior conversation context omitted.'
     })
   }
 

package/src/core/memory/memory-manager.ts

@@ -175,7 +175,7 @@ export class MemoryManager {
     this.updateIndex()
   }
 
-  buildSystemReminder(context: string, maxTokens: number = 5000): string {
+  buildSystemReminder(context: string, maxTokens: number = 15000): string {
     const relevant = this.recall(context, 10)
     if (relevant.length === 0) return ''
 

package/src/core/session-store.ts

@@ -84,7 +84,11 @@ export class SessionStore {
     renameSync(tmp, path)
 
     // Incremental index update — only touch this session's entry
-    SessionStore.updateIndexEntry(name, session.metadata)
+    try {
+      SessionStore.updateIndexEntry(name, session.metadata)
+    } catch {
+      // Index update is best-effort; .jsonl data is already safe
+    }
   }
 
   /**
@@ -233,25 +237,29 @@ export class SessionStore {
     writeFileSync(summaryPath, `# ${name}\n\n${summary}\n\nTags: ${tags.join(', ')}\n`, 'utf-8')
 
     // Update index entry — create minimal one if not present
-    const index = SessionStore.loadIndexRaw()
-    const entry = index.find((e) => e.name === name)
-    if (entry) {
-      entry.summary = summary
-      entry.tags = tags
-    } else {
-      index.push({
-        name,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        provider: 'unknown',
-        model: 'unknown',
-        messageCount: 0,
-        tokenCount: 0,
-        summary,
-        tags,
-      })
+    try {
+      const index = SessionStore.loadIndexRaw()
+      const entry = index.find((e) => e.name === name)
+      if (entry) {
+        entry.summary = summary
+        entry.tags = tags
+      } else {
+        index.push({
+          name,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          provider: 'unknown',
+          model: 'unknown',
+          messageCount: 0,
+          tokenCount: 0,
+          summary,
+          tags,
+        })
+      }
+      writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), 'utf-8')
+    } catch {
+      // Index write is best-effort
     }
-    writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), 'utf-8')
   }
 
   /**
@@ -259,9 +267,40 @@ export class SessionStore {
    */
   static getLatest(): SessionIndexEntry | null {
     const index = SessionStore.loadIndexRaw()
-    if (index.length === 0) return null
-    index.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
-    return index[0]!
+    if (index.length > 0) {
+      index.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+      return index[0]!
+    }
+    // Fallback: scan .jsonl files directly when index is missing
+    return SessionStore.scanLatestFromDisk()
+  }
+
+  /** Scan .jsonl files on disk by mtime — fallback when .index.json is missing. */
+  private static scanLatestFromDisk(): SessionIndexEntry | null {
+    ensureDir()
+    const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith('.jsonl'))
+    if (files.length === 0) return null
+    let latest: { name: string; mtime: number } | null = null
+    for (const file of files) {
+      const stat = statSync(join(SESSIONS_DIR, file))
+      if (!latest || stat.mtimeMs > latest.mtime) {
+        latest = { name: file.replace('.jsonl', ''), mtime: stat.mtimeMs }
+      }
+    }
+    if (!latest) return null
+    // Load the session to extract metadata
+    const session = SessionStore.load(latest.name)
+    if (!session) return null
+    return {
+      name: latest.name,
+      createdAt: session.metadata.createdAt,
+      updatedAt: session.metadata.updatedAt,
+      provider: session.metadata.provider,
+      model: session.metadata.model,
+      messageCount: session.metadata.messageCount,
+      tokenCount: 0,
+      cwd: session.metadata.cwd,
+    }
   }
 
   /**

package/src/core/tokenizer.ts

@@ -0,0 +1,80 @@
+import type { Tiktoken } from 'js-tiktoken'
+import type { Message } from '../shared/types'
+
+let encoder: Tiktoken | null = null
+let initPromise: Promise<void> | null = null
+
+async function getEncoder(): Promise<Tiktoken> {
+  if (encoder) return encoder
+  if (!initPromise) {
+    initPromise = (async () => {
+      const { getEncoding } = await import('js-tiktoken')
+      encoder = getEncoding('cl100k_base')
+    })()
+  }
+  await initPromise
+  return encoder!
+}
+
+export class TokenCounter {
+  private cache = new Map<string, number>()
+  private initialized = false
+
+  private async ensureInit(): Promise<void> {
+    if (!this.initialized) {
+      await getEncoder()
+      this.initialized = true
+    }
+  }
+
+  async count(text: string): Promise<number> {
+    if (!text) return 0
+    const cached = this.cache.get(text)
+    if (cached !== undefined) return cached
+    await this.ensureInit()
+    const tokens = encoder!.encode(text).length
+    this.cache.set(text, tokens)
+    return tokens
+  }
+
+  /** Synchronous fallback — chars/4 heuristic when WASM not loaded. */
+  countSync(text: string): number {
+    if (!text) return 0
+    const cached = this.cache.get(text)
+    if (cached !== undefined) return cached
+    return Math.ceil(text.length / 4)
+  }
+
+  async countMessages(messages: Message[]): Promise<number> {
+    let total = 0
+    for (const msg of messages) {
+      if (typeof msg.content === 'string') {
+        total += await this.count(msg.content)
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === 'text' && block.text) {
+            total += await this.count(block.text)
+          }
+        }
+      }
+      total += 4 // per-message format overhead
+    }
+    return total
+  }
+
+  async truncateToTokens(text: string, maxTokens: number): Promise<string> {
+    await this.ensureInit()
+    const tokens = encoder!.encode(text)
+    if (tokens.length <= maxTokens) return text
+    return text.slice(0, Math.floor(text.length * (maxTokens / tokens.length)))
+  }
+
+  invalidateCache(): void {
+    this.cache.clear()
+  }
+
+  static reset(): void {
+    encoder = null
+    initPromise = null
+  }
+}

package/src/index.tsx

@@ -120,7 +120,15 @@ export async function runApp(options: RunOptions): Promise<void> {
     )
   }
 
-  const context = new ContextManager({ maxTokens: contextMaxTokens, compactionThreshold: 0.9 })
+  const useRealTokenizer = config.features?.context?.useRealTokenizer !== false
+  const adaptiveThresholds = config.features?.context?.adaptiveThresholds !== false
+  const effectiveContextWindow = adaptiveThresholds ? modelContextWindow : 200_000
+
+  const context = new ContextManager({
+    maxTokens: contextMaxTokens,
+    compactionThreshold: 0.9,
+    contextWindow: effectiveContextWindow,
+  })
 
   if (options.resume) {
     const saved = SessionStore.load(options.resume)
@@ -153,6 +161,15 @@ export async function runApp(options: RunOptions): Promise<void> {
     if (latestSession?.summary) {
       prompt = `${prompt}\n\n<system-context name="previous-session">\n# Previous Session Summary\n${latestSession.summary}\n</system-context>`
     }
+
+    // Key expiry reminder (Task 7)
+    const { KeyManager } = await import('./config/keys-manager')
+    const keyManager = new KeyManager()
+    const keyReminder = keyManager.getExpiryReminder()
+    if (keyReminder) {
+      prompt = `${prompt}\n\n<system-reminder name="key-expiry">\n${keyReminder}\n</system-reminder>`
+    }
+
     context.setSystemPrompt(prompt)
   }
 

package/src/mcp/client.ts

@@ -8,6 +8,8 @@ import type {
 } from './types'
 import { StdioTransport } from './transport'
 import { McpProtocol } from './protocol'
+import { OAuthClient } from './oauth'
+import { TokenStore } from './token-store'
 
 interface ActiveConnection {
   config: McpServerConfig
@@ -32,6 +34,19 @@ interface ActiveConnection {
 export class McpClient {
   private static instance: McpClient | null = null
   private connections = new Map<string, ActiveConnection>()
+  private _tokenStore: TokenStore | null = null
+  private _oauthClient: OAuthClient | null = null
+  private eventHandlers = new Map<string, Array<(...args: any[]) => void>>()
+
+  private get tokenStore(): TokenStore {
+    if (!this._tokenStore) this._tokenStore = new TokenStore()
+    return this._tokenStore
+  }
+
+  private get oauthClient(): OAuthClient {
+    if (!this._oauthClient) this._oauthClient = new OAuthClient(this.tokenStore)
+    return this._oauthClient
+  }
 
   /** Get or create the singleton instance. */
   static getInstance(): McpClient {
@@ -41,6 +56,80 @@ export class McpClient {
     return McpClient.instance
   }
 
+  on(event: string, handler: (...args: any[]) => void): void {
+    const list = this.eventHandlers.get(event) || []
+    list.push(handler)
+    this.eventHandlers.set(event, list)
+  }
+
+  private emit(event: string, ...args: any[]): void {
+    const list = this.eventHandlers.get(event) || []
+    for (const h of list) h(...args)
+  }
+
+  /** Connect with OAuth PKCE flow — injects access token into env vars. */
+  async connectWithOAuth(config: McpServerConfig): Promise<void> {
+    const accessToken = await this.oauthClient.getValidAccessToken(config.name, config)
+    return this.connect({
+      ...config,
+      env: { ...config.env, MCP_ACCESS_TOKEN: accessToken },
+    })
+  }
+
+  /** Handle tools/list_changed notification — diff and re-register. */
+  async onToolsChanged(name: string): Promise<void> {
+    const connection = this.connections.get(name)
+    if (!connection || connection.status !== 'connected') return
+
+    const oldToolNames = new Set(connection.tools.map((t) => t.name))
+    const newTools = await connection.protocol.listTools()
+    const newToolNames = new Set(newTools.map((t) => t.name))
+
+    const added = newTools.filter((t) => !oldToolNames.has(t.name))
+    const removed = connection.tools.filter((t) => !newToolNames.has(t.name))
+
+    connection.tools = newTools
+
+    if (added.length > 0 || removed.length > 0) {
+      this.emit('tools-changed', name, added, removed)
+    }
+  }
+
+  /** Reconnect with exponential backoff (1s→2s→4s→…max 60s, 10 attempts). */
+  async reconnect(name: string): Promise<void> {
+    const connection = this.connections.get(name)
+    if (!connection) throw new Error(`No connection for "${name}"`)
+
+    const config = connection.config
+    let delay = 1000
+    const maxDelay = 60000
+    const maxAttempts = 10
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        try {
+          connection.transport.close()
+        } catch {
+          /* ok */
+        }
+        this.connections.delete(name)
+
+        await this.connect(config)
+        this.emit('reconnected', name)
+        return
+      } catch (err) {
+        if (attempt === maxAttempts) {
+          connection.status = 'error'
+          connection.error = String(err)
+          this.emit('disconnected', name, err)
+          throw err
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay))
+        delay = Math.min(delay * 2, maxDelay)
+      }
+    }
+  }
+
   /** Reset the singleton (useful for testing). */
   static resetInstance(): void {
     McpClient.instance = null
@@ -74,6 +163,11 @@ export class McpClient {
       connection.status = 'connected'
       connection.serverInfo = initResult.serverInfo
 
+      // Wire tools-changed notification
+      protocol.on('tools-changed', async () => {
+        await this.onToolsChanged(config.name)
+      })
+
       // Discover tools
       if (initResult.capabilities.tools) {
         connection.tools = await protocol.listTools()

package/src/mcp/oauth.ts

@@ -0,0 +1,167 @@
+import { randomBytes, createHash } from 'node:crypto'
+import { createServer, Server } from 'node:http'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { McpServerConfig } from '../shared/types'
+import { TokenStore } from './token-store'
+
+interface TokenResponse {
+  accessToken: string
+  refreshToken?: string
+  expiresAt: string
+  scopes?: string[]
+}
+
+function base64url(buf: Buffer): string {
+  return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+export class OAuthClient {
+  constructor(private store: TokenStore) {}
+
+  generatePkcePair(): { codeVerifier: string; codeChallenge: string } {
+    const codeVerifier = base64url(randomBytes(64))
+    const hash = createHash('sha256').update(codeVerifier).digest()
+    const codeChallenge = base64url(hash)
+    return { codeVerifier, codeChallenge }
+  }
+
+  async executePkceFlow(config: McpServerConfig): Promise<TokenResponse> {
+    const auth = config.auth!
+    const port = auth.redirectPort || 19876
+    const { codeVerifier, codeChallenge } = this.generatePkcePair()
+    const state = base64url(randomBytes(32))
+
+    const code = await new Promise<string>((resolve, reject) => {
+      const server: Server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+        const url = new URL(req.url || '/', `http://localhost:${port}`)
+        if (url.pathname === '/callback') {
+          const receivedCode = url.searchParams.get('code')
+          const receivedState = url.searchParams.get('state')
+          if (receivedState !== state) {
+            res.writeHead(400)
+            res.end('State mismatch')
+            reject(new Error('OAuth state mismatch — possible CSRF'))
+            return
+          }
+          if (!receivedCode) {
+            res.writeHead(400)
+            res.end('No code received')
+            reject(new Error('No authorization code received'))
+            return
+          }
+          res.writeHead(200, { 'Content-Type': 'text/html' })
+          res.end(
+            '<html><body><h1>Authenticated</h1><p>You may close this window.</p></body></html>',
+          )
+          server.close()
+          resolve(receivedCode)
+        }
+      })
+      server.listen(port, () => {
+        const authUrl = new URL(auth.authorizationUrl)
+        authUrl.searchParams.set('response_type', 'code')
+        authUrl.searchParams.set('client_id', auth.clientId)
+        authUrl.searchParams.set('code_challenge', codeChallenge)
+        authUrl.searchParams.set('code_challenge_method', 'S256')
+        authUrl.searchParams.set('redirect_uri', `http://localhost:${port}/callback`)
+        authUrl.searchParams.set('state', state)
+        if (auth.scopes?.length) {
+          authUrl.searchParams.set('scope', auth.scopes.join(' '))
+        }
+        const cmd =
+          process.platform === 'darwin'
+            ? `open "${authUrl.toString()}"`
+            : process.platform === 'win32'
+              ? `start "" "${authUrl.toString()}"`
+              : `xdg-open "${authUrl.toString()}"`
+        const { exec } = require('node:child_process')
+        exec(cmd, () => {
+          /* fire-and-forget */
+        })
+      })
+      setTimeout(() => {
+        server.close()
+        reject(new Error('OAuth flow timed out (5 minutes)'))
+      }, 300_000)
+    })
+
+    const tokenResponse = await fetch(auth.tokenUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'authorization_code',
+        code,
+        code_verifier: codeVerifier,
+        redirect_uri: `http://localhost:${port}/callback`,
+        client_id: auth.clientId,
+      }).toString(),
+    })
+
+    if (!tokenResponse.ok) {
+      const body = await tokenResponse.text()
+      throw new Error(`Token exchange failed: ${tokenResponse.status} ${body}`)
+    }
+
+    const data = (await tokenResponse.json()) as {
+      access_token: string
+      refresh_token?: string
+      expires_in?: number
+      scope?: string
+    }
+
+    const result: TokenResponse = {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresAt: new Date(Date.now() + (data.expires_in || 3600) * 1000).toISOString(),
+      scopes: data.scope?.split(' '),
+    }
+
+    this.store.save(config.name, result)
+    return result
+  }
+
+  async getValidAccessToken(serverName: string, config: McpServerConfig): Promise<string> {
+    const saved = this.store.load(serverName)
+    if (saved && new Date(saved.expiresAt).getTime() > Date.now() + 60000) {
+      return saved.accessToken
+    }
+    if (saved?.refreshToken) {
+      return this.refreshAccessToken(serverName, config)
+    }
+    const fresh = await this.executePkceFlow(config)
+    return fresh.accessToken
+  }
+
+  async refreshAccessToken(serverName: string, config: McpServerConfig): Promise<string> {
+    const saved = this.store.load(serverName)
+    if (!saved?.refreshToken) {
+      throw new Error(`No refresh token available for "${serverName}"`)
+    }
+    const auth = config.auth!
+    const response = await fetch(auth.tokenUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: saved.refreshToken,
+        client_id: auth.clientId,
+      }).toString(),
+    })
+    if (!response.ok) {
+      this.store.delete(serverName)
+      const fresh = await this.executePkceFlow(config)
+      return fresh.accessToken
+    }
+    const data = (await response.json()) as {
+      access_token: string
+      refresh_token?: string
+      expires_in?: number
+    }
+    this.store.save(serverName, {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token || saved.refreshToken,
+      expiresAt: new Date(Date.now() + (data.expires_in || 3600) * 1000).toISOString(),
+    })
+    return data.access_token
+  }
+}

package/src/mcp/protocol.ts

@@ -18,9 +18,21 @@ export class McpProtocol {
     tools?: { listChanged?: boolean }
     resources?: { subscribe?: boolean; listChanged?: boolean }
   } = {}
+  private handlers = new Map<string, Array<(...args: any[]) => void>>()
 
   constructor(private transport: StdioTransport) {}
 
+  on(event: string, handler: (...args: any[]) => void): void {
+    const list = this.handlers.get(event) || []
+    list.push(handler)
+    this.handlers.set(event, list)
+  }
+
+  private emit(event: string, ...args: any[]): void {
+    const list = this.handlers.get(event) || []
+    for (const h of list) h(...args)
+  }
+
   async initialize(
     serverCommand: string,
     serverArgs: string[],
@@ -45,6 +57,13 @@ export class McpProtocol {
     // Send initialized notification
     this.transport.sendNotification('notifications/initialized')
 
+    // Register notification handler for tools/list_changed
+    this.transport.onNotification((notification) => {
+      if (notification.method === 'notifications/tools/list_changed') {
+        this.emit('tools-changed', notification.params)
+      }
+    })
+
     this.serverCapabilities = result.capabilities
 
     return result

package/src/mcp/token-store.ts

@@ -0,0 +1,105 @@
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  readdirSync,
+  chmodSync,
+} from 'node:fs'
+import { join, dirname } from 'node:path'
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
+import { homedir } from 'node:os'
+
+const ALGORITHM = 'aes-256-gcm'
+const IV_LENGTH = 16
+const AUTH_TAG_LENGTH = 16
+const KEY_LENGTH = 32
+
+interface TokenData {
+  accessToken: string
+  refreshToken?: string
+  expiresAt: string
+  createdAt?: string
+  scopes?: string[]
+}
+
+function getEncryptionKey(keyPath: string): Buffer {
+  if (existsSync(keyPath)) {
+    return readFileSync(keyPath)
+  }
+  const key = randomBytes(KEY_LENGTH)
+  mkdirSync(dirname(keyPath), { recursive: true })
+  writeFileSync(keyPath, key)
+  chmodSync(keyPath, 0o400)
+  return key
+}
+
+function encrypt(plaintext: string, key: Buffer): string {
+  const iv = randomBytes(IV_LENGTH)
+  const cipher = createCipheriv(ALGORITHM, key, iv)
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf-8'), cipher.final()])
+  const authTag = cipher.getAuthTag()
+  return Buffer.concat([iv, authTag, encrypted]).toString('base64')
+}
+
+function decrypt(ciphertext: string, key: Buffer): string {
+  const buf = Buffer.from(ciphertext, 'base64')
+  const iv = buf.subarray(0, IV_LENGTH)
+  const authTag = buf.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH)
+  const encrypted = buf.subarray(IV_LENGTH + AUTH_TAG_LENGTH)
+  const decipher = createDecipheriv(ALGORITHM, key, iv)
+  decipher.setAuthTag(authTag)
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8')
+}
+
+export class TokenStore {
+  private key: Buffer
+  private storeDir: string
+
+  constructor(storeDir?: string) {
+    this.storeDir = storeDir || join(homedir(), '.mipham', 'mcp-tokens')
+    const keyPath = join(dirname(this.storeDir), '.mcp-key')
+    this.key = getEncryptionKey(keyPath)
+  }
+
+  save(serverName: string, data: TokenData): void {
+    mkdirSync(this.storeDir, { recursive: true })
+    const filePath = join(this.storeDir, `${serverName}.enc`)
+    const json = JSON.stringify({
+      ...data,
+      createdAt: data.createdAt || new Date().toISOString(),
+    })
+    const encrypted = encrypt(json, this.key)
+    writeFileSync(filePath, encrypted, { mode: 0o600 })
+    try {
+      chmodSync(filePath, 0o600)
+    } catch {
+      /* Windows — chmod is a no-op */
+    }
+  }
+
+  load(serverName: string): TokenData | null {
+    const filePath = join(this.storeDir, `${serverName}.enc`)
+    if (!existsSync(filePath)) return null
+    try {
+      const encrypted = readFileSync(filePath, 'utf-8')
+      const json = decrypt(encrypted, this.key)
+      return JSON.parse(json) as TokenData
+    } catch {
+      return null
+    }
+  }
+
+  delete(serverName: string): void {
+    const filePath = join(this.storeDir, `${serverName}.enc`)
+    if (existsSync(filePath)) unlinkSync(filePath)
+  }
+
+  list(): string[] {
+    if (!existsSync(this.storeDir)) return []
+    return readdirSync(this.storeDir)
+      .filter((f) => f.endsWith('.enc'))
+      .map((f) => f.replace('.enc', ''))
+  }
+}

package/src/security/gate.ts

@@ -0,0 +1,93 @@
+export interface GateResult {
+  blocked: boolean
+  reason?: string
+}
+
+const PROMPT_INJECTION_PATTERNS: Array<{ regex: RegExp; label: string }> = [
+  {
+    regex: /ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?)/i,
+    label: 'ignore-previous-instructions',
+  },
+  {
+    regex: /^system\s*:\s*(now\s+)?(act|pretend|you\s+are)/im,
+    label: 'role-impersonation',
+  },
+  {
+    regex: /(^|\n)(---\s*BEGIN|<\|\w+\|>)/,
+    label: 'delimiter-injection',
+  },
+  {
+    regex: /you\s+are\s+now\s+(dan|jailbroken|unrestricted)/i,
+    label: 'dan-jailbreak',
+  },
+  {
+    regex:
+      /(disregard|override|supersede)\s+(all\s+)?(previous|prior|above|system)\s+(instructions?|rules?|prompts?)/i,
+    label: 'override-instructions',
+  },
+]
+
+const DANGEROUS_BASH_PATTERNS: Array<{ regex: RegExp; label: string }> = [
+  { regex: /\$\(.+\)/, label: 'command-substitution' },
+  { regex: /`[^`]+`/, label: 'backtick-substitution' },
+  { regex: /;\s*(rm|cat|sh|bash)\b/, label: 'command-chain-injection' },
+  { regex: /curl.+\|\s*(sh|bash)\b/, label: 'curl-pipe-shell' },
+  { regex: /\|\s*(sh|bash)\b/, label: 'pipe-to-shell' },
+  { regex: />\s*\/dev\//, label: 'redirect-to-dev' },
+]
+
+const API_KEY_PATTERNS: Array<{ regex: RegExp; label: string }> = [
+  { regex: /sk-ant-[a-zA-Z0-9_-]{20,}/, label: 'anthropic-key' },
+  { regex: /sk-[a-zA-Z0-9]{32,}/, label: 'openai-key' },
+  { regex: /eyJ[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{10,}/, label: 'jwt-token' },
+  { regex: /x-api-key:\s*[a-zA-Z0-9_-]{20,}/i, label: 'api-key-header' },
+]
+
+export class SecurityGate {
+  static checkPromptInjection(input: string): GateResult {
+    if (!input || input.length < 10) return { blocked: false }
+    for (const pattern of PROMPT_INJECTION_PATTERNS) {
+      if (pattern.regex.test(input)) {
+        return { blocked: true, reason: `prompt injection detected: ${pattern.label}` }
+      }
+    }
+    return { blocked: false }
+  }
+
+  static checkPathTraversal(path: string, _cwd: string): GateResult {
+    if (!path) return { blocked: false }
+    if (/\0/.test(path)) {
+      return { blocked: true, reason: 'null byte in path' }
+    }
+    if (/%25|%2e%2e/i.test(path)) {
+      return { blocked: true, reason: 'double-encoded path traversal' }
+    }
+    const segments = path.replace(/\\/g, '/').split('/')
+    for (const seg of segments) {
+      if (seg === '..') {
+        return { blocked: true, reason: 'path traversal attempt (..)' }
+      }
+    }
+    return { blocked: false }
+  }
+
+  static checkBashCommand(command: string): GateResult {
+    if (!command) return { blocked: false }
+    for (const pattern of DANGEROUS_BASH_PATTERNS) {
+      if (pattern.regex.test(command)) {
+        return { blocked: true, reason: `dangerous bash pattern: ${pattern.label}` }
+      }
+    }
+    return { blocked: false }
+  }
+
+  static checkCredentialLeak(output: string): GateResult {
+    if (!output || output.length < 10) return { blocked: false }
+    for (const pattern of API_KEY_PATTERNS) {
+      if (pattern.regex.test(output)) {
+        return { blocked: true, reason: `credential leak detected: ${pattern.label}` }
+      }
+    }
+    return { blocked: false }
+  }
+}

package/src/shared/types.ts

@@ -177,6 +177,14 @@ export interface McpServerConfig {
   command: string
   args: string[]
   env?: Record<string, string>
+  auth?: {
+    type: 'oauth'
+    authorizationUrl: string
+    tokenUrl: string
+    clientId: string
+    scopes?: string[]
+    redirectPort?: number
+  }
 }
 
 // ── Skill Types ──

package/src/ui/commands.ts

@@ -24,6 +24,7 @@ import {
 } from '../commands/project.js'
 import { themeCmd, releaseNotesCmd, ideCmd, terminalSetupCmd } from '../commands/environment.js'
 import { commitCmd, pushCmd, prCmd, issueCmd } from '../commands/git.js'
+import { keysCmd } from '../commands/keys'
 
 export interface CommandContext {
   engine: QueryEngine
@@ -187,6 +188,9 @@ const helpCmd: CommandHandler = (ctx) => {
       ── Account ─────────────────────────
       /login         Show API key status
       /logout        Clear credentials guide
+      /keys          List API key rotation status
+      /keys rotate   Rotate an API key
+      /keys audit    Check for expired keys
       /feedback      Send feedback
 
       ── Agents ──────────────────────────
@@ -2489,9 +2493,67 @@ const deepResearchCmd: CommandHandler = (_ctx, args) => {
 // Theme — display theme toggle
 // ═══════════════════════════════════════════════════════════════
 
-const mcpCmd: CommandHandler = (ctx) => {
+const mcpCmd: CommandHandler = async (ctx, args) => {
+  const client = McpClient.getInstance()
+  const sub = args[0]?.toLowerCase()
+
+  // /mcp connect <name>
+  if (sub === 'connect') {
+    const name = args[1]
+    if (!name) return { content: 'Usage: /mcp connect <server-name>' }
+    const mcpServers = ctx.config.skills?.mcpServers ?? []
+    const config = mcpServers.find((s) => s.name === name)
+    if (!config) {
+      return {
+        content: `Server "${name}" not found in config.\n\nConfigured: ${mcpServers.map((s) => s.name).join(', ') || '(none)'}`,
+      }
+    }
+    if (config.auth?.type === 'oauth') {
+      return {
+        content: [
+          `── MCP Connect: ${name} (OAuth) ──`,
+          '',
+          'Starting OAuth PKCE flow...',
+          `Authorization: ${config.auth.authorizationUrl}`,
+          `Scopes: ${config.auth.scopes?.join(', ') || '(default)'}`,
+        ].join('\n'),
+        forwardToAI: `Connect to MCP server "${name}" using OAuth. Call McpClient.getInstance().connectWithOAuth() with the server config, then register its tools. Report the result.`,
+      }
+    }
+    return {
+      content: `── MCP Connect: ${name} ──\n\nConnecting via stdio...`,
+      forwardToAI: `Connect to MCP server "${name}" using McpClient.getInstance().connect(config), then register its tools. Report the result.`,
+    }
+  }
+
+  // /mcp disconnect <name>
+  if (sub === 'disconnect') {
+    const name = args[1]
+    if (!name) return { content: 'Usage: /mcp disconnect <server-name>' }
+    const tools = client.disconnect(name)
+    return {
+      content: [
+        `── MCP Disconnect: ${name} ──`,
+        '',
+        tools.length > 0
+          ? `Disconnected. ${tools.length} tool(s) removed.`
+          : 'Disconnected (no tools were registered).',
+      ].join('\n'),
+    }
+  }
+
+  // /mcp reload
+  if (sub === 'reload') {
+    return {
+      content: '── MCP Reload ──\n\nDisconnecting all and reconnecting...',
+      forwardToAI:
+        'Disconnect all MCP servers via McpClient.getInstance().closeAll(), then reconnect all configured servers. Report each status.',
+    }
+  }
+
+  // /mcp (default status)
   const configuredServers = ctx.config.skills?.mcpServers ?? []
-  const liveConnections = McpClient.getInstance().listConnections()
+  const liveConnections = client.listConnections()
 
   const lines: string[] = ['── MCP Servers ──', '']
 
@@ -2510,52 +2572,26 @@ const mcpCmd: CommandHandler = (ctx) => {
               : '⚪'
         : '⚪'
       const statusLabel = live ? live.status : 'not started'
-      const envKeys = s.env ? Object.keys(s.env).join(', ') : '(none)'
-
-      lines.push(`  ${statusIcon} ${s.name}  [${statusLabel}]`)
+      const oauthTag = s.auth?.type === 'oauth' ? ' [OAuth]' : ''
+      lines.push(`  ${statusIcon} ${s.name}${oauthTag}  [${statusLabel}]`)
       lines.push(`     Command: ${s.command} ${s.args.join(' ')}`)
-      lines.push(`     Env vars: ${envKeys}`)
       if (live?.tools && live.tools.length > 0) {
-        lines.push(`     Tools: ${live.tools.map((t) => t.name).join(', ')}`)
-      }
-      if (live?.error) {
-        lines.push(`     Error: ${live.error}`)
-      }
-      if (live?.serverInfo) {
-        lines.push(`     Server: ${live.serverInfo.name} v${live.serverInfo.version}`)
+        lines.push(`     Tools: ${live.tools.length} registered`)
       }
+      if (live?.error) lines.push(`     Error: ${live.error}`)
       lines.push('')
     }
   } else {
     lines.push('No MCP servers configured.')
-    lines.push('')
-    lines.push('── Configuration ──')
-    lines.push('')
-    lines.push('Add MCP servers to .mipham/config.yml:')
-    lines.push('')
-    lines.push('  skills:')
-    lines.push('    mcpServers:')
-    lines.push('      - name: filesystem')
-    lines.push('        command: npx')
-    lines.push('        args: ["-y", "@anthropic/mcp-filesystem", "/path"]')
-    lines.push('        env:')
-    lines.push('          HOME: $HOME')
-    lines.push('')
-    lines.push('      - name: github')
-    lines.push('        command: npx')
-    lines.push('        args: ["-y", "@anthropic/mcp-github"]')
-    lines.push('        env:')
-    lines.push('          GITHUB_TOKEN: $GITHUB_TOKEN')
-    lines.push('')
-    lines.push('After configuring, restart Mipham Code to connect.')
-    lines.push('Use the MCP tool (Tool 16) to call server tools.')
   }
 
+  lines.push('── Commands ──')
+  lines.push('  /mcp connect <name>    Connect to a server (OAuth or stdio)')
+  lines.push('  /mcp disconnect <name>  Disconnect from a server')
+  lines.push('  /mcp reload            Disconnect all and reconnect')
   lines.push('')
   lines.push('── Protocol ──')
   lines.push('MCP stdio transport (JSON-RPC 2.0) — fully implemented.')
-  lines.push('Servers auto-connect on startup when configured.')
-  lines.push('')
   lines.push('Learn more: https://modelcontextprotocol.io')
 
   return { content: lines.join('\n') }
@@ -3122,6 +3158,9 @@ const commandsListCmd: CommandHandler = () => {
     '/release-notes': 'Environment',
     '/login': 'Account',
     '/logout': 'Account',
+    '/keys': 'Account',
+    '/keys rotate': 'Account',
+    '/keys audit': 'Account',
     '/feedback': 'Account',
     '/agents': 'Agents',
     '/bg': 'Agents',
@@ -3273,6 +3312,9 @@ registry.set('/release-notes', releaseNotesCmd)
 registry.set('/mcp', mcpCmd)
 registry.set('/login', loginCmd)
 registry.set('/logout', logoutCmd)
+registry.set('/keys', keysCmd)
+registry.set('/keys rotate', keysCmd)
+registry.set('/keys audit', keysCmd)
 registry.set('/feedback', feedbackCmd)
 registry.set('/agents', agentsCmd)
 registry.set('/bg', bgCmd)
@@ -3399,6 +3441,9 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/upgrade': 'Show upgrade instructions',
   '/login': 'Show API key status',
   '/logout': 'Clear credentials guide',
+  '/keys': 'List API key rotation status',
+  '/keys rotate': 'Rotate an API key',
+  '/keys audit': 'Check for expired keys',
   '/feedback': 'Send feedback',
   '/agents': 'Agent view dashboard',
   '/bg': 'Run a background agent task',