@miphamai/cli 0.38.0 → 0.39.0

package/bin/mipham.ts

@@ -1144,6 +1144,7 @@ Usage:
   mipham --help              Show this help
 
 Flags:
+  --dump-config              Print the assembled profile tree
   --safe-mode                Skip custom agents, skills, hooks, plugins
   --version, -v, -V          Print version
 
@@ -1152,6 +1153,30 @@ npm:  https://www.npmjs.com/package/@miphamai/cli`)
     process.exit(0)
   }
 
+  // ── Dump config flag ───────────────────────────────────────────────────────
+  if (process.argv.includes('--dump-config')) {
+    const { homedir } = await import('node:os')
+    const { join } = await import('node:path')
+    const { existsSync } = await import('node:fs')
+    const { loadProfile, loadBundle, assemble, dumpConfig } = await import('../src/vajra/compose')
+
+    const profileIdx = process.argv.indexOf('--profile')
+    const profileName =
+      profileIdx !== -1 && process.argv[profileIdx + 1] ? process.argv[profileIdx + 1]! : 'default'
+    const dir = join(homedir(), '.mipham', 'profiles')
+    const profilePath = join(dir, `${profileName}.yml`)
+
+    if (!existsSync(profilePath)) {
+      console.error(`Profile "${profileName}" not found at ${profilePath}`)
+      process.exit(1)
+    }
+
+    const profile = loadProfile(profilePath)
+    const resolveBundle = (name: string) => loadBundle(join(dir, `${name}.yml`))
+    console.log(dumpConfig(assemble(profile, resolveBundle)))
+    process.exit(0)
+  }
+
   // ── Update / upgrade ──────────────────────────────────────────────────────
   const handledUpdate = await runUpdate()
   if (handledUpdate) return

package/package.json

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

package/src/agent/sub-agent.ts

@@ -1,4 +1,5 @@
 import type { ProviderRegistry } from '../providers/registry'
+import type { Llm } from '../providers/llm'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { SubAgentType, SubAgentOptions, AgentDefinition } from './types'
 import { createAgentContext } from './agent-context'
@@ -44,6 +45,7 @@ export class SubAgent {
     private permission?: PermissionSystem,
     private hookEngine?: HookEngine,
     private ruleEngine?: ExperienceRuleEngine,
+    private llm?: Llm,
   ) {}
 
   /**
@@ -189,8 +191,7 @@ export class SubAgent {
     options: SubAgentOptions,
     signal?: AbortSignal,
   ): Promise<string> {
-    const provider = this.registry.getActive()
-    if (!provider) {
+    if (!this.registry.getActive()) {
       throw new Error('No active provider available for sub-agent execution')
     }
 
@@ -332,7 +333,7 @@ export class SubAgent {
         const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
         let turnText = ''
 
-        for await (const chunk of provider.chat({
+        for await (const chunk of (this.llm ?? this.registry).chat({
           model: finalModel,
           messages: currentMessages,
           systemPrompt: currentSystemPrompt,

package/src/config/defaults.ts

@@ -41,7 +41,17 @@ export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {
 
 export const DEFAULT_CREDENTIAL_MASKING_CONFIG: CredentialMaskingConfig = {
   enabled: true,
-  files: [],
+  // Default sensitive-file rules: full-mask any of these before the model sees them.
+  files: [
+    { path: '**/.env*', mode: 'full' },
+    { path: '**/.aws/credentials', mode: 'full' },
+    { path: '**/.aws/config', mode: 'full' },
+    { path: '**/.ssh/id_*', mode: 'full' },
+    { path: '**/*.pem', mode: 'full' },
+    { path: '**/*.key', mode: 'full' },
+    { path: '**/.netrc', mode: 'full' },
+    { path: '**/credentials.*', mode: 'full' },
+  ],
   output_scrubbing: {
     enabled: true,
     patterns: ['(?i)(api[_-]?key|secret|token|password|credential)\\s*[:=]\\s*\\S+'],
@@ -52,6 +62,14 @@ export const DEFAULT_CREDENTIAL_MASKING_CONFIG: CredentialMaskingConfig = {
   },
 }
 
+/** 掩码中立配置：Read/Bash 照常挂载，但不启用任何凭据掩码（对齐 pre-seam 无参行为）。 */
+export const DISABLED_CREDENTIAL_MASKING_CONFIG: CredentialMaskingConfig = {
+  enabled: false,
+  files: [],
+  output_scrubbing: { enabled: false, patterns: [] },
+  env_filter: { enabled: false, patterns: [] },
+}
+
 export const DEFAULT_BACKGROUND_AGENT_CONFIG: BackgroundAgentConfig = {
   auto_commit: true,
   auto_push: true,

package/src/config/keys-manager.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import { homedir } from 'node:os'
+import { saveProviderApiKey } from './loader'
 
 const MIPHAM_DIR = join(homedir(), '.mipham')
 const KEYS_FILE = join(MIPHAM_DIR, 'keys.json')
@@ -67,7 +68,16 @@ export class KeyManager {
     }))
   }
 
-  rotate(provider: string, _newKey: string): { success: boolean; message: string } {
+  rotate(provider: string, newKey: string): { success: boolean; message: string } {
+    // Persist the new key first — the actual rotation. Metadata below is only
+    // bookkeeping; without writing the key, "rotate" would be a silent no-op.
+    if (!saveProviderApiKey(provider, newKey)) {
+      return {
+        success: false,
+        message: `Rotation aborted: failed to persist new key for "${provider}".`,
+      }
+    }
+
     const data = loadKeys()
     const now = new Date().toISOString()
     const existing = data[provider]

package/src/config/loader.ts

@@ -58,6 +58,7 @@ function safeParseYaml(path: string, label: string): Partial<MiphamConfig> | nul
 function mergeProviders(
   baseProviders: ProviderConfig[],
   overrideProviders: ProviderConfig[],
+  allowBaseUrlOverride: boolean,
 ): ProviderConfig[] {
   const merged = [...baseProviders]
 
@@ -75,7 +76,10 @@ function mergeProviders(
       id: base.id,
       name: op.name || base.name,
       protocol: op.protocol || base.protocol,
-      baseUrl: op.baseUrl ?? base.baseUrl,
+      // baseUrl is a routing field — it decides where the user's API key is
+      // sent, so only trusted (user-level) config may override it. Untrusted
+      // (project-level) config cannot redirect a built-in provider's traffic.
+      baseUrl: allowBaseUrlOverride ? (op.baseUrl ?? base.baseUrl) : base.baseUrl,
       apiKey: op.apiKey ?? base.apiKey,
       models: op.models?.length ? op.models : base.models,
       status: op.status ?? base.status,
@@ -85,10 +89,14 @@ function mergeProviders(
   return merged
 }
 
-function mergeConfig(base: MiphamConfig, override: Partial<MiphamConfig>): MiphamConfig {
+function mergeConfig(
+  base: MiphamConfig,
+  override: Partial<MiphamConfig>,
+  allowBaseUrlOverride: boolean,
+): MiphamConfig {
   const merged: MiphamConfig = { ...base, ...override }
   if (override.providers) {
-    merged.providers = mergeProviders(base.providers, override.providers)
+    merged.providers = mergeProviders(base.providers, override.providers, allowBaseUrlOverride)
   } else {
     merged.providers = base.providers
   }
@@ -216,7 +224,7 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
   // ── Load project-level config ──
   const projectConfig = safeParseYaml(configPath, 'project config')
   if (projectConfig) {
-    config = mergeConfig(config, projectConfig)
+    config = mergeConfig(config, projectConfig, false)
   } else if (existsSync(configPath)) {
     // File exists but failed to parse — try to restore from backup
     process.stderr.write(`⚠ Mipham Code: project config is corrupted, attempting recovery...\n`)
@@ -226,7 +234,7 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
       // Retry parsing after restore
       const restored = safeParseYaml(configPath, 'restored project config')
       if (restored) {
-        config = mergeConfig(config, restored)
+        config = mergeConfig(config, restored, false)
       }
     }
   }
@@ -234,7 +242,7 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
   // ── Load user-level config ──
   const userConfig = safeParseYaml(userConfigPath, 'user config')
   if (userConfig) {
-    config = mergeConfig(config, userConfig)
+    config = mergeConfig(config, userConfig, true)
   } else if (existsSync(userConfigPath)) {
     // File exists but failed to parse — try to restore from backup
     process.stderr.write(`⚠ Mipham Code: user config is corrupted, attempting recovery...\n`)
@@ -244,7 +252,7 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
       // Retry parsing after restore
       const restored = safeParseYaml(userConfigPath, 'restored user config')
       if (restored) {
-        config = mergeConfig(config, restored)
+        config = mergeConfig(config, restored, true)
       }
     }
   } else {
@@ -286,13 +294,15 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
  *
  * Returns default (disabled) config if no inference_hooks section is present.
  */
-export function loadInferenceHookConfig(cwd: string = process.cwd()): InferenceHookConfig {
-  const configPath = join(cwd, '.mipham', 'config.yml')
+export function loadInferenceHookConfig(): InferenceHookConfig {
+  // DLP is a user/org-level security setting — the endpoint controls where the
+  // entire conversation is sent, so a project config must NOT be able to
+  // redirect it (exfiltration). Read only from the user-level config.
   const userConfigPath = join(MIPHAM_HOME, 'config.yml')
 
   let merged = { ...DEFAULT_INFERENCE_HOOK_CONFIG }
 
-  const paths = [userConfigPath, configPath] // project wins (loaded last)
+  const paths = [userConfigPath]
   for (const path of paths) {
     try {
       if (!existsSync(path)) continue

package/src/core/context.ts

@@ -1,9 +1,14 @@
-import type { Message } from '../shared/index.ts'
+import type { Message, ToolResult } from '../shared/index.ts'
 import { snipMessages } from './context-snip'
 import { microcompact } from './context-microcompact'
-import { reactiveCompact } from './context-compact'
-import { emergencyDrain } from './context-drain'
 import { NoopCacheTracker, type CacheTracker, type CacheStatus } from './context-token'
+import {
+  SessionLog,
+  messageToEvents,
+  deriveMessages,
+  assertModelVisible,
+  isAssertModelVisibleDebug,
+} from './session-log'
 
 export type Summarizer = (messages: Message[], heading: string) => Promise<string>
 
@@ -18,9 +23,6 @@ export interface CompactionStats {
   snipMessagesRemoved: number
   microcompactCount: number
   microcompactTokensSaved: number
-  compactCount: number
-  compactTokensSaved: number
-  drainCount: number
   lastCompaction: Date | null
 }
 
@@ -47,9 +49,6 @@ export class ContextManager {
     snipMessagesRemoved: 0,
     microcompactCount: 0,
     microcompactTokensSaved: 0,
-    compactCount: 0,
-    compactTokensSaved: 0,
-    drainCount: 0,
     lastCompaction: null,
   }
   private compressionPending = false
@@ -58,6 +57,24 @@ export class ContextManager {
     this.calculateThresholds()
   }
 
+  private log?: SessionLog
+
+  /** 附加一个 append-only 会话日志；addMessage/seedMessages 将写通镜像到日志。 */
+  setLog(log?: SessionLog): void {
+    this.log = log
+  }
+
+  getLog(): SessionLog | undefined {
+    return this.log
+  }
+
+  /** 从已持久化的日志恢复：设 log 为源，messages 为投影（不重复写通）。 */
+  restoreLog(log: SessionLog): void {
+    this.log = log
+    this.messages = deriveMessages(log.events())
+    this.reEstimateTokens()
+  }
+
   /**
    * Calculate adaptive compaction thresholds based on the model's context window.
    *
@@ -112,10 +129,36 @@ export class ContextManager {
       typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
     )
 
+    if (this.log) {
+      for (const e of messageToEvents(msg, Date.now())) this.log.append(e)
+    }
+
+    if (this.log && isAssertModelVisibleDebug()) {
+      assertModelVisible(this.log.events(), this.messages)
+    }
+
     // Auto-trigger compression checks (fire-and-forget, don't await)
     this.checkCompression()
   }
 
+  /** 记录工具执行结果（全量 ToolResult 含 success/error）到日志，并写投影消息（不重复走 messageToEvents 拆分）。 */
+  addToolResult(toolUseId: string, result: ToolResult): void {
+    const content = result.success ? result.content : result.error || result.content
+    const msg: Message = {
+      role: 'user',
+      content: [{ type: 'tool_result', tool_use_id: toolUseId, content }],
+    }
+    this.messages.push(msg)
+    this.estimatedTokens += this.estimateTokens(JSON.stringify(msg.content))
+    if (this.log) this.log.append({ type: 'tool/result', at: Date.now(), id: toolUseId, result })
+    this.checkCompression()
+  }
+
+  /** 记录原始 assistant 流块（保 replay 保真）；不写入投影 messages。 */
+  recordChunk(chunk: string): void {
+    if (this.log) this.log.append({ type: 'assistant/chunk', at: Date.now(), chunk })
+  }
+
   /**
    * Seed a batch of pre-existing messages (e.g., an inherited parent
    * conversation). Unlike addMessage, this does not trigger compaction so the
@@ -124,7 +167,14 @@ export class ContextManager {
   seedMessages(messages: Message[]): void {
     if (messages.length === 0) return
     this.messages.push(...messages)
+    if (this.log) {
+      for (const m of messages) for (const e of messageToEvents(m, Date.now())) this.log.append(e)
+    }
     this.reEstimateTokens()
+
+    if (this.log && isAssertModelVisibleDebug()) {
+      assertModelVisible(this.log.events(), this.messages)
+    }
   }
 
   getMessages(): Message[] {
@@ -155,13 +205,30 @@ export class ContextManager {
           content: `[Earlier conversation summary]: ${summary}`,
         }
         this.messages = [summaryMsg, ...this.messages.slice(-keep)]
+        if (this.log) {
+          const derivedCount = deriveMessages(this.log.events()).length
+          const replacedCount = Math.max(0, derivedCount - keep)
+          this.log.append({ type: 'compaction/summary', at: Date.now(), summary, replacedCount })
+        }
       } catch {
         // Fall back to truncation on summarizer failure
-        this.messages = this.messages.slice(-keep)
+        const kept = this.messages.slice(-keep)
+        if (this.log) {
+          this.log.append({ type: 'compaction/rewrite', at: Date.now(), messages: kept })
+          this.messages = deriveMessages(this.log.events())
+        } else {
+          this.messages = kept
+        }
       }
     } else {
       // Simple truncation fallback
-      this.messages = this.messages.slice(-keep)
+      const kept = this.messages.slice(-keep)
+      if (this.log) {
+        this.log.append({ type: 'compaction/rewrite', at: Date.now(), messages: kept })
+        this.messages = deriveMessages(this.log.events())
+      } else {
+        this.messages = kept
+      }
     }
 
     // Re-estimate tokens
@@ -280,50 +347,6 @@ export class ContextManager {
     return { ...this.compactionStats }
   }
 
-  // ── 413 recovery ──
-
-  /**
-   * Emergency context drain for 413 (context too large) errors.
-   * Progressively strips messages until the context fits.
-   * Returns true if recovery was possible, false if already minimal.
-   */
-  async on413Error(): Promise<boolean> {
-    const result = await emergencyDrain(this)
-    if (result.recovered) {
-      this.compactionStats.drainCount++
-      this.compactionStats.lastCompaction = new Date()
-    }
-    return result.recovered
-  }
-
-  // ── Forced compaction (e.g. /compact command) ──
-
-  /**
-   * Force compaction of the conversation history.
-   *
-   * Uses the provided summarizer, the internal summarizer, or falls back
-   * to emergency drain if neither is available.
-   */
-  async forceCompact(heading: string, summarizer?: Summarizer): Promise<void> {
-    const beforeTokens = this.estimatedTokens
-
-    if (summarizer) {
-      await reactiveCompact(this, summarizer, heading)
-    } else if (this.summarizer) {
-      await reactiveCompact(this, this.summarizer, heading)
-    } else {
-      // Fallback: simple truncation via drain
-      await emergencyDrain(this)
-    }
-
-    const tokensSaved = beforeTokens - this.estimatedTokens
-    this.compactionStats.compactCount++
-    if (tokensSaved > 0) {
-      this.compactionStats.compactTokensSaved += tokensSaved
-    }
-    this.compactionStats.lastCompaction = new Date()
-  }
-
   // ── Private compression helpers ──
 
   /**
@@ -373,7 +396,14 @@ export class ContextManager {
       this.compactionStats.lastCompaction = new Date()
     }
 
-    this.messages = compacted
+    // 仅当内容真变时写日志并重建投影（model-visible means logged 不变量）。
+    // 用 deriveMessages(log) 而非直接赋值 compacted，避免与日志事件共享 messages 引用被 addMessage.push 污染。
+    if (this.log && (removed > 0 || tokensSaved > 0)) {
+      this.log.append({ type: 'compaction/rewrite', at: Date.now(), messages: compacted })
+      this.messages = deriveMessages(this.log.events())
+    } else {
+      this.messages = compacted
+    }
     this.reEstimateTokens()
   }
 

package/src/core/credential-masker/output-scrub.ts

@@ -1,5 +1,6 @@
 import { CREDENTIAL_SENTINEL } from './types'
 import type { CredentialMaskingConfig } from '../../shared/index.ts'
+import { SecurityGate } from '../../security/gate'
 
 /**
  * Well-known secret token prefixes. These are high-signal formats that must
@@ -23,6 +24,10 @@ export function maskOutput(output: string, config: CredentialMaskingConfig): str
   // Redact bare secret tokens by prefix (always on, independent of config patterns).
   masked = masked.replace(TOKEN_REDACTION_PATTERN, CREDENTIAL_SENTINEL)
 
+  // Redact bare sk-/sk-ant-/JWT tokens — wire the SecurityGate credential-leak
+  // detection into the output path (defense-in-depth beyond the config patterns).
+  masked = SecurityGate.redactCredentialLeak(masked)
+
   for (const pattern of config.output_scrubbing.patterns) {
     try {
       // Strip (?i) inline flags — JS uses the 'i' flag instead

package/src/core/crsi-sandbox.ts

@@ -16,7 +16,7 @@
 
 import { execSync } from 'node:child_process'
 import { mkdirSync, rmSync, existsSync, writeFileSync, readFileSync, readdirSync } from 'node:fs'
-import { join, resolve } from 'node:path'
+import { join, resolve, sep } from 'node:path'
 import { tmpdir, homedir } from 'node:os'
 import { randomUUID } from 'node:crypto'
 
@@ -172,7 +172,16 @@ export class CrsiSandbox {
       phase: 'pending',
     }
 
-    const targetPath = join(this.worktreePath, mod.filePath)
+    const worktreeRoot = resolve(this.worktreePath)
+    const targetPath = resolve(this.worktreePath, mod.filePath)
+
+    // Path traversal guard: reject any target that resolves outside the sandbox worktree
+    if (targetPath !== worktreeRoot && !targetPath.startsWith(worktreeRoot + sep)) {
+      result.error = `Path traversal blocked: "${mod.filePath}" resolves outside the worktree.`
+      result.phase = 'failed'
+      this.sessionReport.modifications.push(result)
+      return result
+    }
 
     // Verify the file exists in the worktree
     if (!existsSync(targetPath)) {
@@ -182,7 +191,7 @@ export class CrsiSandbox {
       return result
     }
 
-    // Verify original content matches (safety check)
+    // Verify original content matches (safety check — empty originalContent = lenient skip)
     try {
       const currentContent = readFileSync(targetPath, 'utf-8')
       if (currentContent !== mod.originalContent && mod.originalContent) {
@@ -319,12 +328,15 @@ export class CrsiSandbox {
       return { success: false, message: 'No worktree to merge from.' }
     }
 
-    // Check that all modifications passed tests
-    const failedCount = this.sessionReport.modifications.filter((m) => m.phase === 'failed').length
-    if (failedCount > 0) {
+    // Require every modification to have passed tests before merging. A mod left
+    // in 'pending'/'applied'/'testing' (tests never run or never passed) must not merge.
+    const mergeable = new Set(['passed', 'approved', 'merged'])
+    const blockers = this.sessionReport.modifications.filter((m) => !mergeable.has(m.phase))
+    if (blockers.length > 0) {
+      const phases = [...new Set(blockers.map((m) => m.phase))].join(', ')
       return {
         success: false,
-        message: `${failedCount} modification(s) failed tests. Cannot merge.`,
+        message: `${blockers.length} modification(s) not ready to merge (phase: ${phases}). Cannot merge.`,
       }
     }