@miphamai/cli 0.44.4 → 0.45.1

package/package.json

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

package/src/core/engine.ts

@@ -86,6 +86,8 @@ export class QueryEngine {
   private goal?: string
   private maxGoalLoops = 20
   private lastAssistantContent?: string
+  /** Reasoning effort (low|medium|high|xhigh|max) — scales the provider idle timeout. */
+  private effort: string = 'high'
   /** Custom verification shell script path for goal checking. */
   private goalVerifyScript?: string
   /** Custom verification skill name for goal checking. */
@@ -117,6 +119,11 @@ export class QueryEngine {
     dialogExpiry: 300,
   }
 
+  /** Set the reasoning effort (low|medium|high|xhigh|max). */
+  setEffort(level: string): void {
+    this.effort = level
+  }
+
   /** Set the session identifier (called from index.tsx at startup with the actual session name). */
   setSessionId(id: string): void {
     this.sessionId = id
@@ -1209,6 +1216,7 @@ export class QueryEngine {
         systemPrompt,
         tools: toolDefs,
         signal,
+        effort: this.effort,
       })) {
         if (chunk.type === 'error') {
           failure = chunk.error ?? 'Unknown error'
@@ -1253,6 +1261,7 @@ export class QueryEngine {
         systemPrompt,
         tools: toolDefs,
         signal,
+        effort: this.effort,
       })) {
         yield chunk
       }

package/src/daemon/remote-engine.ts

@@ -224,6 +224,9 @@ export class RemoteEngine {
   /** No-op: provider switching is managed by the daemon session. */
   switchProvider(_providerId: string, _modelId?: string): void {}
 
+  /** No-op: reasoning effort is managed by the daemon session. */
+  setEffort(_level: string): void {}
+
   /** Remote mode has no local agent registry. */
   getAgentRegistry(): undefined {
     return undefined

package/src/providers/anthropic.ts

@@ -6,7 +6,7 @@ import type {
   ContentBlock,
 } from '../shared/index.ts'
 import type { ProviderInstance, ChatRequest } from './registry'
-import { fetchWithRetry } from './fetch-utils'
+import { fetchWithRetry, streamIdleTimeoutMs } from './fetch-utils'
 
 interface AnthropicContentBlock {
   type: string
@@ -109,24 +109,33 @@ export class AnthropicProvider implements ProviderInstance {
     const decoder = new TextDecoder()
     let buffer = ''
 
-    // Streaming read timeout: if no data arrives for 90s, abort to prevent UI freeze.
-    const STREAM_READ_TIMEOUT_MS = 90_000
+    // Streaming idle timeout: scaled by reasoning effort so extended thinking
+    // passes aren't mistaken for a stalled connection.
+    const STREAM_READ_TIMEOUT_MS = streamIdleTimeoutMs(req.effort)
 
     while (true) {
       let readResult: Awaited<ReturnType<typeof reader.read>>
+      let idleTimer: ReturnType<typeof setTimeout> | undefined
       try {
         readResult = await Promise.race([
           reader.read(),
-          new Promise<never>((_, reject) =>
-            setTimeout(
-              () => reject(new Error('Stream read timeout — no data for 90s')),
+          new Promise<never>((_, reject) => {
+            idleTimer = setTimeout(
+              () =>
+                reject(
+                  new Error(
+                    `Stream read timeout — no data for ${Math.round(STREAM_READ_TIMEOUT_MS / 1000)}s`,
+                  ),
+                ),
               STREAM_READ_TIMEOUT_MS,
-            ),
-          ),
+            )
+          }),
         ])
       } catch (err) {
         yield { type: 'error', error: `Stream stalled: ${String(err)}` }
         return
+      } finally {
+        if (idleTimer) clearTimeout(idleTimer)
       }
       const { done, value } = readResult
       if (done) break

package/src/providers/fetch-utils.ts

@@ -80,6 +80,28 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
+// ── Streaming idle-timeout (stall guard) with effort multiplier ──────────
+//
+// Reasoning models think silently for long stretches. The idle timeout between
+// stream chunks is scaled by reasoning effort so a long thinking pass isn't
+// mistaken for a stalled connection (jcode stall-guard alignment).
+
+/** Base idle timeout between stream chunks, in ms. */
+export const STREAM_IDLE_TIMEOUT_BASE_MS = 90_000
+
+/** Effort level → idle-timeout multiplier. Unknown/absent effort → 1× (base). */
+const EFFORT_TIMEOUT_MULTIPLIER: Record<string, number> = {
+  high: 2,
+  xhigh: 3,
+  max: 4,
+}
+
+/** Compute the streaming idle timeout for a given reasoning-effort level. */
+export function streamIdleTimeoutMs(effort?: string): number {
+  const multiplier = effort ? (EFFORT_TIMEOUT_MULTIPLIER[effort] ?? 1) : 1
+  return STREAM_IDLE_TIMEOUT_BASE_MS * multiplier
+}
+
 /**
  * Combine multiple AbortSignals into one — any signal aborting
  * triggers the combined signal.

package/src/providers/openai-compat.ts

@@ -1,7 +1,7 @@
 import { execSync } from 'node:child_process'
 import type { ProviderConfig, ModelInfo, Message, StreamChunk } from '../shared/index.ts'
 import type { ProviderInstance, ChatRequest } from './registry'
-import { fetchWithRetry } from './fetch-utils'
+import { fetchWithRetry, streamIdleTimeoutMs } from './fetch-utils'
 import { OLLAMA_PRESET_MODELS } from '../shared/constants'
 
 export class OpenAICompatProvider implements ProviderInstance {
@@ -54,25 +54,33 @@ export class OpenAICompatProvider implements ProviderInstance {
     const pendingToolCalls = new Map<number, { id: string; name: string; arguments: string }>()
     let reasoningContent = ''
 
-    // Streaming read timeout: if no data arrives for 90s, abort to prevent UI freeze.
-    // DeepSeek V4 thinking mode can take 30-60s between chunks — 90s is a generous ceiling.
-    const STREAM_READ_TIMEOUT_MS = 90_000
+    // Streaming idle timeout: scaled by reasoning effort so long thinking passes
+    // (DeepSeek V4 / reasoning models) aren't mistaken for a stalled connection.
+    const STREAM_READ_TIMEOUT_MS = streamIdleTimeoutMs(req.effort)
 
     while (true) {
       let readResult: Awaited<ReturnType<typeof reader.read>>
+      let idleTimer: ReturnType<typeof setTimeout> | undefined
       try {
         readResult = await Promise.race([
           reader.read(),
-          new Promise<never>((_, reject) =>
-            setTimeout(
-              () => reject(new Error('Stream read timeout — no data for 90s')),
+          new Promise<never>((_, reject) => {
+            idleTimer = setTimeout(
+              () =>
+                reject(
+                  new Error(
+                    `Stream read timeout — no data for ${Math.round(STREAM_READ_TIMEOUT_MS / 1000)}s`,
+                  ),
+                ),
               STREAM_READ_TIMEOUT_MS,
-            ),
-          ),
+            )
+          }),
         ])
       } catch (err) {
         yield { type: 'error', error: `Stream stalled: ${String(err)}` }
         return
+      } finally {
+        if (idleTimer) clearTimeout(idleTimer)
       }
       const { done, value } = readResult
       if (done) break

package/src/providers/registry.ts

@@ -17,6 +17,8 @@ export interface ChatRequest {
   maxTokens?: number
   temperature?: number
   signal?: AbortSignal
+  /** Reasoning effort (low|medium|high|xhigh|max) — scales the streaming idle timeout. */
+  effort?: string
 }
 
 export class ProviderRegistry implements Llm {

package/src/security/path.ts

@@ -7,6 +7,30 @@ import { realpathSync, existsSync } from 'node:fs'
  */
 const BLOCKED_PATHS = ['/etc', '/proc', '/sys', '/dev', '/boot', '/root']
 
+/**
+ * Windows UNC paths and NT/Win32/DOS device-namespace prefixes.
+ *
+ * Accessing a UNC path (\\server\share) triggers SMB negotiation on Windows,
+ * which silently sends NTLM credentials to the target — a credential-leak
+ * vector (relay / offline cracking). The NT-namespace spelling (\??\UNC\...)
+ * bypasses naive UNC checks, so all device-namespace prefixes are rejected too.
+ *
+ * Anchored at token boundaries so escaped backslashes (echo \\n) and local
+ * drive paths (C:\\Users\\me) are NOT flagged, and http:// URLs are excluded
+ * from the forward-slash form.
+ */
+const UNC_DEVICE_PATTERNS: RegExp[] = [
+  /(?:^|[\s"'`(;|&])\\\\[A-Za-z0-9._-]+\\[^\s"'`;|&]/,
+  /(?:^|[\s"'`(;|&])\/\/[A-Za-z0-9._-]+\/[^\s"'`;|&]/,
+  /\\\?\?\\/,
+  /\\\\\?\\/,
+  /\\\\\.\\/,
+]
+
+export function isUncOrDevicePath(path: string): boolean {
+  return UNC_DEVICE_PATTERNS.some((re) => re.test(path))
+}
+
 /**
  * Resolve a user-supplied path relative to cwd, with sandbox enforcement.
  *
@@ -22,6 +46,14 @@ const BLOCKED_PATHS = ['/etc', '/proc', '/sys', '/dev', '/boot', '/root']
  * @throws {Error} with a human-readable message if the path is blocked.
  */
 export function resolveSafe(cwd: string, inputPath: string): string {
+  // Reject UNC / device-namespace paths before touching the filesystem —
+  // resolving a UNC path on Windows would trigger SMB negotiation (NTLM leak).
+  if (isUncOrDevicePath(inputPath)) {
+    throw new Error(
+      `Path rejected: "${inputPath}" is a UNC or device-namespace path (blocked to prevent NTLM credential leakage).`,
+    )
+  }
+
   const raw = resolve(cwd, inputPath)
   const normalized = normalize(raw)
 

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.44.4' as const
+export const PACKAGE_VERSION = '0.45.1' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/skills/mipham/runtime.ts

@@ -54,9 +54,12 @@ export class MiphamRuntime {
       ...variables,
     }
 
-    for (const [key, value] of Object.entries(allVars)) {
-      result = result.replaceAll(`\${${key}}`, value)
-    }
+    // Single-pass substitution: replacement values are NOT re-scanned for more
+    // template markers, so a variable containing `${key}` can't be re-expanded
+    // into another variable's value.
+    result = result.replace(/\$\{([^}]+)\}/g, (match, key: string) =>
+      Object.prototype.hasOwnProperty.call(allVars, key) ? allVars[key]! : match,
+    )
 
     return result
   }

package/src/skills/standard/runtime.ts

@@ -49,9 +49,12 @@ export class StandardRuntime {
 
     let result = prompt
     if (variables) {
-      for (const [key, value] of Object.entries(variables)) {
-        result = result.replaceAll(`\${${key}}`, value)
-      }
+      // Single-pass substitution: replacement values are NOT re-scanned for
+      // more template markers, so an argument containing `${key}` can't be
+      // re-expanded into another variable's value.
+      result = result.replace(/\$\{([^}]+)\}/g, (match, key: string) =>
+        Object.prototype.hasOwnProperty.call(variables, key) ? variables[key]! : match,
+      )
     }
 
     return result

package/src/tools/exec/bash.ts

@@ -1,6 +1,7 @@
 import type { ToolDefinition, CredentialMaskingConfig } from '../../shared/index.ts'
 import { sanitizeCommand } from '../../shared/sanitize.ts'
 import { DANGEROUS_GIT_PATTERNS } from './git.ts'
+import { isUncOrDevicePath } from '../../security/path.ts'
 import type { Service } from '../../vajra'
 import { toolKey } from '../seam'
 import { withValidation } from '../validation'
@@ -137,6 +138,12 @@ export function isBlocked(command: string): string | null {
     }
   }
 
+  // Reject UNC / device-namespace paths — accessing one triggers SMB negotiation
+  // on Windows and silently leaks NTLM credentials (Claude Code 2.1.233 CVE-class fix).
+  if (isUncOrDevicePath(command) || isUncOrDevicePath(normalized) || isUncOrDevicePath(sanitized)) {
+    return `Command rejected: references a UNC or device-namespace path (blocked to prevent NTLM credential leakage).`
+  }
+
   // Check dangerous patterns (on original, normalized, and sanitized)
   for (const pattern of BLOCKED_PATTERNS) {
     if (pattern.test(command) || pattern.test(normalized) || pattern.test(sanitized)) {

package/src/tools/file/grep.ts

@@ -1,7 +1,28 @@
-import { $ } from 'bun'
 import type { ToolDefinition } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
 
+/** Grep stall guard: a search over a huge tree (or a pathological regex) must
+ *  not hang the session for minutes. Matches the Bash tool's 120s ceiling. */
+const GREP_TIMEOUT_MS = 120_000
+
+/** Run a search command with a kill-timer; report whether the timeout fired. */
+export async function runSearch(
+  cmd: string[],
+  cwd: string,
+  timeoutMs: number,
+): Promise<{ stdout: string; timedOut: boolean; exitCode: number | null }> {
+  const proc = Bun.spawn(cmd, { cwd, stdout: 'pipe', stderr: 'pipe' })
+  let timedOut = false
+  const timer = setTimeout(() => {
+    timedOut = true
+    proc.kill()
+  }, timeoutMs)
+  const stdout = await new Response(proc.stdout).text()
+  await proc.exited
+  clearTimeout(timer)
+  return { stdout, timedOut, exitCode: proc.exitCode }
+}
+
 export const grepTool: ToolDefinition = {
   name: 'Grep',
   description:
@@ -29,32 +50,52 @@ export const grepTool: ToolDefinition = {
     const searchPath = resolveSafe(ctx.cwd, (params.path as string) || '.')
     const include = params.include as string | undefined
 
+    // 1. ripgrep (fast path)
+    const rgArgs = ['rg', '-n', '--heading', '--color=never', '-M', '500', pattern]
+    if (include) rgArgs.push('--glob', include)
+    rgArgs.push(searchPath)
     try {
-      const args = ['-n', '--heading', '--color=never', '-M', '500', pattern]
-      if (include) args.push('--glob', include)
-      args.push(searchPath)
-
-      const result = await $`rg ${args}`.cwd(ctx.cwd).quiet().text()
-      return { success: true, content: result || '(no matches)' }
-    } catch (err: unknown) {
-      const exitErr = err as { exitCode?: number }
-      if (exitErr.exitCode === 1) {
-        return { success: true, content: '(no matches)' }
-      }
-      // Fallback to grep
-      try {
-        const content = await $`grep -rn ${pattern} ${searchPath}`.cwd(ctx.cwd).quiet().text()
+      const { stdout, timedOut, exitCode } = await runSearch(rgArgs, ctx.cwd, GREP_TIMEOUT_MS)
+      if (timedOut) {
         return {
-          success: true,
-          content: content.slice(0, 50000) || '(no matches)',
+          success: false,
+          content: '',
+          error: `Grep timed out after ${GREP_TIMEOUT_MS / 1000}s — narrow scope with "path" and "include".`,
         }
-      } catch {
+      }
+      if (exitCode === 1) return { success: true, content: '(no matches)' }
+      if (exitCode === 0) return { success: true, content: stdout || '(no matches)' }
+      // rg exit 2 (error) or null (killed) → fall through to grep
+    } catch {
+      // rg not installed → fall through to grep
+    }
+
+    // 2. fallback to plain grep
+    const grepArgs = ['grep', '-rn', pattern, searchPath]
+    try {
+      const { stdout, timedOut, exitCode } = await runSearch(grepArgs, ctx.cwd, GREP_TIMEOUT_MS)
+      if (timedOut) {
         return {
           success: false,
           content: '',
-          error: 'grep failed. Install ripgrep: brew install ripgrep',
+          error: `Grep timed out after ${GREP_TIMEOUT_MS / 1000}s — narrow scope with "path" and "include".`,
         }
       }
+      if (exitCode === 1) return { success: true, content: '(no matches)' }
+      if (exitCode === 0) {
+        return { success: true, content: stdout.slice(0, 50000) || '(no matches)' }
+      }
+      return {
+        success: false,
+        content: '',
+        error: 'grep failed. Install ripgrep: brew install ripgrep',
+      }
+    } catch {
+      return {
+        success: false,
+        content: '',
+        error: 'grep failed. Install ripgrep: brew install ripgrep',
+      }
     }
   },
 }

package/src/ui/app.tsx

@@ -278,6 +278,7 @@ export function App({
       setEffort: (level: string) => {
         setEffort(level)
         setPreference('lastCodeReviewEffort', level)
+        engine.setEffort(level)
       },
       setFocusMode: (on: boolean) => setFocusMode(on),
       setGoal: (text: string) => setGoalText(text),

package/src/ui/chat.tsx

@@ -83,6 +83,10 @@ const MessageRow = React.memo(
               <Text bold color="green">
                 ▸ {displayCwd()}:
               </Text>
+            ) : msg.role === 'assistant' ? (
+              <Text bold color="magenta">
+                ◆ {t('ui.assistant.role_label')}:
+              </Text>
             ) : msg.role === 'system' ? (
               <Text bold color="yellow">
                 ⚠ {t('ui.system.role_label')}: