@miphamai/cli 0.18.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.18.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/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)

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/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

@@ -2493,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 ──', '']
 
@@ -2514,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') }