@miphamai/cli 0.6.9 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.6.9",
+  "version": "0.7.1",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/core/engine.ts

@@ -148,6 +148,7 @@ export class QueryEngine {
 
     let assistantContent = ''
     let reasoningContent = ''
+    let thinkingContent = ''
     const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
     // Stream model response
@@ -174,6 +175,10 @@ export class QueryEngine {
           reasoningContent += chunk.reasoning_content
         }
 
+        if (chunk.type === 'thinking' && chunk.thinking) {
+          thinkingContent += chunk.thinking
+        }
+
         if (chunk.type === 'tool_use' && chunk.toolUse) {
           toolUses.push({
             id: chunk.toolUse.id,
@@ -184,10 +189,17 @@ export class QueryEngine {
 
         if (chunk.type === 'stop') {
           // Add assistant response to context
-          if (assistantContent || reasoningContent) {
+          if (assistantContent || reasoningContent || thinkingContent) {
+            const contentBlocks: import('../shared/types').ContentBlock[] = []
+            if (thinkingContent) {
+              contentBlocks.push({ type: 'thinking', thinking: thinkingContent })
+            }
+            if (assistantContent) {
+              contentBlocks.push({ type: 'text', text: assistantContent })
+            }
             const msg: import('../shared/types').Message = {
               role: 'assistant',
-              content: assistantContent || '',
+              content: thinkingContent ? contentBlocks : assistantContent || '',
             }
             if (reasoningContent) msg.reasoning_content = reasoningContent
             this.context.addMessage(msg)
@@ -197,10 +209,17 @@ export class QueryEngine {
     } catch (err) {
       if (isAbortError(err)) {
         // User interrupted — keep partial content, stop gracefully
-        if (assistantContent || reasoningContent) {
+        if (assistantContent || reasoningContent || thinkingContent) {
+          const contentBlocks: import('../shared/types').ContentBlock[] = []
+          if (thinkingContent) {
+            contentBlocks.push({ type: 'thinking', thinking: thinkingContent })
+          }
+          if (assistantContent) {
+            contentBlocks.push({ type: 'text', text: assistantContent })
+          }
           const msg: import('../shared/types').Message = {
             role: 'assistant',
-            content: assistantContent || '',
+            content: thinkingContent ? contentBlocks : assistantContent || '',
           }
           if (reasoningContent) msg.reasoning_content = reasoningContent
           this.context.addMessage(msg)
@@ -236,13 +255,21 @@ export class QueryEngine {
       }
 
       // Add tool use + result to context
+      // DeepSeek V4 thinking mode requires reasoning_content on every assistant message
       this.context.addMessage({
         role: 'assistant',
         content: [{ type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input }],
+        reasoning_content: '',
       })
       this.context.addMessage({
         role: 'user',
-        content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result.content }],
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: toolUse.id,
+            content: result.success ? result.content : result.error || result.content,
+          },
+        ],
       })
     }
 
@@ -282,6 +309,7 @@ export class QueryEngine {
 
       let assistantContent = ''
       let reasoningContent = ''
+      let thinkingContent = ''
       const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
       try {
@@ -301,6 +329,10 @@ export class QueryEngine {
             reasoningContent += chunk.reasoning_content
           }
 
+          if (chunk.type === 'thinking' && chunk.thinking) {
+            thinkingContent += chunk.thinking
+          }
+
           if (chunk.type === 'tool_use' && chunk.toolUse) {
             toolUses.push({
               id: chunk.toolUse.id,
@@ -311,10 +343,17 @@ export class QueryEngine {
         }
       } catch (err) {
         if (isAbortError(err)) {
-          if (assistantContent || reasoningContent) {
+          if (assistantContent || reasoningContent || thinkingContent) {
+            const contentBlocks: import('../shared/types').ContentBlock[] = []
+            if (thinkingContent) {
+              contentBlocks.push({ type: 'thinking', thinking: thinkingContent })
+            }
+            if (assistantContent) {
+              contentBlocks.push({ type: 'text', text: assistantContent })
+            }
             const msg: import('../shared/types').Message = {
               role: 'assistant',
-              content: assistantContent || '',
+              content: thinkingContent ? contentBlocks : assistantContent || '',
             }
             if (reasoningContent) msg.reasoning_content = reasoningContent
             this.context.addMessage(msg)
@@ -326,15 +365,31 @@ export class QueryEngine {
         return
       }
 
-      if (assistantContent || reasoningContent) {
+      if (assistantContent || reasoningContent || thinkingContent) {
+        const contentBlocks: import('../shared/types').ContentBlock[] = []
+        if (thinkingContent) {
+          contentBlocks.push({ type: 'thinking', thinking: thinkingContent })
+        }
+        if (assistantContent) {
+          contentBlocks.push({ type: 'text', text: assistantContent })
+        }
         const msg: import('../shared/types').Message = {
           role: 'assistant',
-          content: assistantContent || '',
+          content: thinkingContent ? contentBlocks : assistantContent || '',
         }
         if (reasoningContent) msg.reasoning_content = reasoningContent
         this.context.addMessage(msg)
       }
 
+      // Safety: prevent silent truncation when max turns reached
+      if (turn === MAX_TURNS - 1 && toolUses.length > 0) {
+        yield {
+          type: 'error',
+          error: `Max tool-calling turns (${MAX_TURNS}) reached. Some tool calls were not executed.`,
+        }
+        return
+      }
+
       // No more tool calls — fire Stop hook and potentially continue
       if (toolUses.length === 0) {
         yield* this.checkStopHook(signal)
@@ -350,13 +405,21 @@ export class QueryEngine {
           content: result.content,
         }
 
+        // DeepSeek V4 thinking mode requires reasoning_content on every assistant message
         this.context.addMessage({
           role: 'assistant',
           content: [{ type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input }],
+          reasoning_content: '',
         })
         this.context.addMessage({
           role: 'user',
-          content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result.content }],
+          content: [
+            {
+              type: 'tool_result',
+              tool_use_id: toolUse.id,
+              content: result.success ? result.content : result.error || result.content,
+            },
+          ],
         })
       }
     }

package/src/index.tsx

@@ -8,6 +8,7 @@ import { loadSessionMemories } from './core/memory/memory-loader'
 import { ContextManager } from './core/context'
 import { QueryEngine } from './core/engine'
 import { SessionStore } from './core/session-store'
+import type { PermissionLevel } from './shared/types'
 import { SkillsLoader } from './skills/loader'
 import { PluginManager } from './plugin/plugin-manager'
 import { loadPlugins } from './plugin/plugin-loader'
@@ -148,6 +149,11 @@ export async function runApp(options: RunOptions): Promise<void> {
   engine.setAgentViewManager(agentViewManager)
   engine.setSkillsLoader(skillsLoader)
 
+  // Sync engine permission with config (fix: UI shows "auto" but engine defaulted to bypass-legacy)
+  if (config.permission) {
+    engine.getPermission().setDefaultLevel(config.permission as PermissionLevel)
+  }
+
   // Initialize agent registry and load plugin agents/skills/MCP/hooks
   const agentRegistry = new AgentRegistry()
   agentRegistry.loadUserAgents()

package/src/mcp/client.ts

@@ -85,16 +85,22 @@ export class McpClient {
     }
   }
 
-  disconnect(name: string): void {
+  /**
+   * Disconnect an MCP server and return the names of its registered tools
+   * so the caller can unregister them from the central tool registry.
+   */
+  disconnect(name: string): string[] {
     const conn = this.connections.get(name)
-    if (!conn) return
+    if (!conn) return []
 
     try {
       conn.transport.close()
     } catch {
       /* best effort */
     }
+    const toolNames = conn.tools.map((t) => t.name)
     this.connections.delete(name)
+    return toolNames
   }
 
   async closeAll(): Promise<void> {

package/src/plugin/plugin-loader.ts

@@ -24,6 +24,9 @@ export function loadPlugins(
   toolsMap: Map<string, ToolDefinition>,
 ): void {
   for (const plugin of pluginManager.getEnabled()) {
+    const mcpServers: string[] = []
+    const hookEvents: HookEvent[] = []
+
     // ── Custom agents ──
     const agentsDir = join(plugin.path, 'agents')
     if (existsSync(agentsDir)) {
@@ -59,6 +62,7 @@ export function loadPlugins(
             const raw = readFileSync(join(mcpDir, entry), 'utf-8')
             const cfg = JSON.parse(raw) as McpServerConfig
             if (cfg.name && cfg.command) {
+              mcpServers.push(cfg.name)
               mcpClient
                 .connect(cfg)
                 .then(() => {
@@ -87,8 +91,6 @@ export function loadPlugins(
     }
 
     // ── Hooks from plugin.json ──
-    // Plugin hooks are HookConfig objects (type + command/url), not HookDefinition
-    // (which requires a handler function). Convert them via executeHook wrapper.
     try {
       const manifestPath = join(plugin.path, 'plugin.json')
       if (existsSync(manifestPath)) {
@@ -100,6 +102,7 @@ export function loadPlugins(
                 | HookEvent
                 | undefined
               if (event) {
+                hookEvents.push(event)
                 hookEngine.register({
                   event,
                   handler: async (ctx) => executeHook(hookCfg, ctx),
@@ -112,5 +115,28 @@ export function loadPlugins(
     } catch (err) {
       process.stderr.write(`[plugin] Failed to load hooks from "${plugin.name}": ${String(err)}\n`)
     }
+
+    // ── Register cleanup callback ──
+    pluginManager.onRemove(plugin.name, () => {
+      // Disconnect MCP servers and unregister their tools
+      for (const serverName of mcpServers) {
+        try {
+          const toolNames = mcpClient.disconnect(serverName)
+          for (const toolName of toolNames) {
+            toolsMap.delete(`mcp__${serverName}__${toolName}`)
+          }
+        } catch {
+          /* best effort */
+        }
+      }
+      // Unregister hooks
+      for (const event of hookEvents) {
+        try {
+          hookEngine.unregister(event)
+        } catch {
+          /* best effort */
+        }
+      }
+    })
   }
 }

package/src/plugin/plugin-manager.ts

@@ -18,6 +18,7 @@ export class PluginManager {
   private plugins: InstalledPlugin[] = []
   private pluginDir: string
   private statePath: string
+  private cleanupCallbacks = new Map<string, () => void>()
 
   constructor(pluginDir?: string) {
     this.pluginDir = pluginDir ?? PLUGIN_DIR
@@ -139,9 +140,29 @@ export class PluginManager {
     return [...this.plugins]
   }
 
+  /**
+   * Register a cleanup callback that will be invoked when the named plugin is removed.
+   * This allows the plugin loader to tear down hooks, agents, MCP connections, and tools.
+   */
+  onRemove(name: string, cleanup: () => void): void {
+    this.cleanupCallbacks.set(name, cleanup)
+  }
+
   remove(name: string): boolean {
     const plugin = this.plugins.find((p) => p.name === name)
     if (!plugin) return false
+
+    // Run registered cleanup: disconnect MCP, unregister hooks/agents/tools
+    const cleanup = this.cleanupCallbacks.get(name)
+    if (cleanup) {
+      try {
+        cleanup()
+      } catch {
+        /* cleanup is best-effort */
+      }
+      this.cleanupCallbacks.delete(name)
+    }
+
     try {
       rmSync(plugin.path, { recursive: true, force: true })
     } catch {

package/src/providers/anthropic.ts

@@ -11,6 +11,7 @@ import { fetchWithRetry } from './fetch-utils'
 interface AnthropicContentBlock {
   type: string
   text?: string
+  thinking?: string
   id?: string
   name?: string
   input?: Record<string, unknown>
@@ -30,6 +31,7 @@ interface AnthropicSSEEvent {
   delta?: {
     type: string
     text?: string
+    thinking?: string
     partial_json?: string
   }
   error?: { type: string; message: string }
@@ -136,6 +138,10 @@ export class AnthropicProvider implements ProviderInstance {
                 yield { type: 'text', content: delta.text }
               }
 
+              if (delta.type === 'thinking_delta' && delta.text) {
+                yield { type: 'thinking', thinking: delta.text }
+              }
+
               if (delta.type === 'input_json_delta' && delta.partial_json) {
                 accumulatedToolInput += delta.partial_json
               }
@@ -215,9 +221,16 @@ export class AnthropicProvider implements ProviderInstance {
       if (msg.role === 'system') continue
 
       if (typeof msg.content === 'string') {
+        const content: unknown[] = [{ type: 'text', text: msg.content }]
+        // DeepSeek V4 thinking mode via Anthropic endpoint: every assistant
+        // message must contain a thinking block if any message in history does.
+        if (msg.role === 'assistant') {
+          const thinkingText = (msg as any).reasoning_content || ''
+          content.unshift({ type: 'thinking', thinking: thinkingText })
+        }
         result.push({
           role: msg.role,
-          content: [{ type: 'text', text: msg.content }],
+          content,
         })
       } else {
         const blocks = (msg.content as ContentBlock[]).map((block) => {
@@ -250,6 +263,12 @@ export class AnthropicProvider implements ProviderInstance {
               }
             }
 
+            case 'thinking':
+              return {
+                type: 'thinking',
+                thinking: block.thinking,
+              }
+
             case 'tool_use':
               return {
                 type: 'tool_use',
@@ -270,6 +289,11 @@ export class AnthropicProvider implements ProviderInstance {
           }
         })
 
+        // DeepSeek V4 thinking mode via Anthropic endpoint: every assistant
+        // message must contain a thinking block if any message in history does.
+        if (msg.role === 'assistant' && !blocks.some((b: any) => b.type === 'thinking')) {
+          blocks.unshift({ type: 'thinking', thinking: '' })
+        }
         result.push({ role: msg.role, content: blocks })
       }
     }

package/src/providers/openai-compat.ts

@@ -172,7 +172,7 @@ export class OpenAICompatProvider implements ProviderInstance {
         const next: Message | undefined = messages[i + 1]
         if (
           msg.role === 'assistant' &&
-          msg.content.length > 0 &&
+          (msg.content.length > 0 || msg.reasoning_content) &&
           next &&
           next.role === 'assistant' &&
           typeof next.content !== 'string' &&
@@ -190,9 +190,8 @@ export class OpenAICompatProvider implements ProviderInstance {
                 arguments: JSON.stringify(tu.input),
               },
             })),
-          }
-          if (msg.reasoning_content) {
-            combinedMsg.reasoning_content = msg.reasoning_content
+            // DeepSeek V4 thinking mode: every assistant message needs reasoning_content
+            reasoning_content: msg.reasoning_content || '',
           }
           result.push(combinedMsg)
           i++ // skip the next message (consumed)
@@ -200,8 +199,9 @@ export class OpenAICompatProvider implements ProviderInstance {
         }
 
         const standaloneMsg: Record<string, unknown> = { role: msg.role, content: msg.content }
-        if (msg.role === 'assistant' && msg.reasoning_content) {
-          standaloneMsg.reasoning_content = msg.reasoning_content
+        // DeepSeek V4 thinking mode: every assistant message needs reasoning_content
+        if (msg.role === 'assistant') {
+          standaloneMsg.reasoning_content = msg.reasoning_content || ''
         }
         result.push(standaloneMsg)
         continue
@@ -214,11 +214,12 @@ export class OpenAICompatProvider implements ProviderInstance {
 
       // ── Assistant tool_use → OpenAI tool_calls ──
       if (toolUses.length > 0 && msg.role === 'assistant') {
-        const textContent =
-          blocks
-            .filter((b) => b.type === 'text')
-            .map((b) => (b.type === 'text' ? b.text : ''))
-            .join('') || null
+        const textParts: string[] = []
+        for (const b of blocks) {
+          if (b.type === 'text') textParts.push(b.text)
+          if (b.type === 'thinking') textParts.push(`[Thinking: ${b.thinking}]`)
+        }
+        const textContent = textParts.join('') || null
 
         const toolUseMsg: Record<string, unknown> = {
           role: 'assistant',
@@ -231,9 +232,8 @@ export class OpenAICompatProvider implements ProviderInstance {
               arguments: JSON.stringify(tu.input),
             },
           })),
-        }
-        if (msg.reasoning_content) {
-          toolUseMsg.reasoning_content = msg.reasoning_content
+          // DeepSeek V4 thinking mode: every assistant message needs reasoning_content
+          reasoning_content: msg.reasoning_content || '',
         }
         result.push(toolUseMsg)
         continue
@@ -241,6 +241,16 @@ export class OpenAICompatProvider implements ProviderInstance {
 
       // ── Tool result → OpenAI tool role ──
       if (toolResults.length > 0) {
+        // Emit companion text blocks as a user message before tool results
+        const textContent =
+          blocks
+            .filter((b) => b.type === 'text')
+            .map((b) => (b.type === 'text' ? b.text : ''))
+            .join('') || null
+        if (textContent) {
+          result.push({ role: 'user', content: textContent })
+        }
+
         for (const tr of toolResults) {
           result.push({
             role: 'tool',

package/src/shared/types.ts

@@ -41,7 +41,16 @@ export interface ToolResultContent {
   tool_use_id: string
   content: string
 }
-export type ContentBlock = TextContent | ImageContent | ToolUseContent | ToolResultContent
+export interface ThinkingContent {
+  type: 'thinking'
+  thinking: string
+}
+export type ContentBlock =
+  | TextContent
+  | ImageContent
+  | ToolUseContent
+  | ToolResultContent
+  | ThinkingContent
 
 export interface Message {
   role: 'system' | 'user' | 'assistant'
@@ -102,13 +111,15 @@ export interface ToolDefinition {
 
 // ── Stream Types ──
 export interface StreamChunk {
-  type: 'text' | 'tool_use' | 'tool_result' | 'stop' | 'error'
+  type: 'text' | 'tool_use' | 'tool_result' | 'thinking' | 'stop' | 'error'
   content?: string
   toolUse?: ToolUseContent
   tool_use_id?: string
   error?: string
   /** DeepSeek reasoning tokens accumulated during this stream. */
   reasoning_content?: string
+  /** Anthropic thinking block content (DeepSeek Anthropic endpoint). */
+  thinking?: string
 }
 
 // ── Config Types ──

package/src/tools/exec/bash.ts

@@ -5,17 +5,46 @@ const BLOCKED_PATTERNS = [
   // Recursive root deletion without preserve-root safeguard
   /\brm\s+-rf\s+\/(\s|$)/,
   /\brm\s+-rf\s+\/\*\s*$/,
+  /\bsudo\s+rm\s+.*\//,
   // Filesystem manipulation
   /\bmkfs\./,
   /\bdd\s+if=/,
   // Fork bomb
   /:\s*\(\s*\)\s*\{\s*:\s*\|/,
   // Recursive root chmod
-  /\bchmod\s+.*777\s+\//,
+  /\bchmod\s+.*(?:777|o\+w|a\+w)\s+\//,
   // Direct block device write
   />\s*\/dev\/sd[a-z]/,
   // SSH private key theft
   /\bcat\s+.*\/\.ssh\/id_/,
+  // Shell command substitution (commonly used for obfuscation/evasion)
+  /\$\(/,
+  // Backtick command substitution
+  /`[^`]+`/,
+  // Interpreter code execution (bypass vector)
+  /\bpython3?\s+-c\b/,
+  /\bpython3?\s+-m\b/,
+  /\bperl\s+-[ep]\b/,
+  /\bruby\s+-e\b/,
+  /\bnode\s+-e\b/,
+  // Reverse shell patterns
+  /\bnc\s+.*-e\b/,
+  /\bncat\s+.*-e\b/,
+  /\bexec\s+\d+<>/,
+  // Download + pipe to interpreter
+  /\bcurl\s+.*\|\s*(?:ba)?sh\b/,
+  /\bwget\s+.*\|\s*(?:ba)?sh\b/,
+  /\bcurl\s+.*\|\s*python/,
+  /\bwget\s+.*\|\s*python/,
+  // Download + execute
+  /\bcurl\s+.*-O\s+\/tmp\/.*\s*&&/,
+  /\bwget\s+.*-O\s+\/tmp\/.*\s*&&/,
+  // Data exfiltration via curl file://
+  /\bcurl\s+file:\/\//,
+  // SCP exfiltration of sensitive files
+  /\bscp\s+.*(?:\.ssh|\.aws|\.env)/,
+  // Write to system paths
+  />\s*\/(?:etc|usr|boot|sys|proc)\//,
 ]
 
 const BLOCKED_COMMANDS = [
@@ -28,6 +57,13 @@ const BLOCKED_COMMANDS = [
   'mkfs.fat',
   'mkfs.vfat',
   'mkswap',
+  'shutdown',
+  'reboot',
+  'halt',
+  'poweroff',
+  'init',
+  'telinit',
+  'systemctl',
 ]
 
 function isBlocked(command: string): string | null {

package/src/tools/file/edit.ts

@@ -24,7 +24,24 @@ export const editTool: ToolDefinition = {
     const newStr = params.new_string as string
     const replaceAll = params.replace_all as boolean
 
+    const MAX_FILE_SIZE = 10_000_000 // 10 MB
+    const MAX_STRING_SIZE = 5_000_000 // 5 MB
+    if (oldStr.length > MAX_STRING_SIZE || newStr.length > MAX_STRING_SIZE) {
+      return {
+        success: false,
+        content: '',
+        error: `String too large. Max: 5 MB per string.`,
+      }
+    }
+
     const content = readFileSync(filePath, 'utf-8')
+    if (content.length > MAX_FILE_SIZE) {
+      return {
+        success: false,
+        content: '',
+        error: `File too large (${(content.length / 1e6).toFixed(1)} MB). Max: 10 MB.`,
+      }
+    }
 
     if (replaceAll) {
       if (!content.includes(oldStr)) {

package/src/tools/file/read.ts

@@ -25,6 +25,15 @@ export const readTool: ToolDefinition = {
     if (stat.isDirectory()) {
       return { success: false, content: '', error: `Path is a directory: ${filePath}` }
     }
+    // Prevent OOM on single-line files (e.g. 500MB JSON blob)
+    const MAX_FILE_SIZE = 50_000_000 // 50 MB
+    if (stat.size > MAX_FILE_SIZE) {
+      return {
+        success: false,
+        content: '',
+        error: `File too large (${(stat.size / 1e6).toFixed(1)} MB). Max: 50 MB. Use offset/limit for large files.`,
+      }
+    }
     const offset = (params.offset as number) || 0
     const limit = (params.limit as number) || 2000
     const content = readFileSync(filePath, 'utf-8')

package/src/tools/file/write.ts

@@ -19,6 +19,16 @@ export const writeTool: ToolDefinition = {
   async execute(params, ctx) {
     const filePath = resolveSafe(ctx.cwd, params.file_path as string)
     const content = params.content as string
+
+    const MAX_CONTENT_SIZE = 10_000_000 // 10 MB
+    if (content.length > MAX_CONTENT_SIZE) {
+      return {
+        success: false,
+        content: '',
+        error: `Content too large (${(content.length / 1e6).toFixed(1)} MB). Max: 10 MB.`,
+      }
+    }
+
     mkdirSync(dirname(filePath), { recursive: true })
     writeFileSync(filePath, content, 'utf-8')
     const lines = content.split('\n').length