@miphamai/cli 0.11.0 → 0.13.0

package/package.json

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

package/src/agent/background-registry.ts

@@ -6,6 +6,8 @@
  * can be queried via the Task tool (output/stop actions) or the Agent View.
  */
 
+export type BackgroundTaskKind = 'interactive' | 'forked' | 'attached' | 'unattended'
+
 export type BackgroundTaskStatus = 'running' | 'completed' | 'failed'
 
 export interface BackgroundTask {
@@ -13,10 +15,17 @@ export interface BackgroundTask {
   description: string
   agentType: string
   status: BackgroundTaskStatus
+  kind: BackgroundTaskKind
   startedAt: Date
   completedAt?: Date
   result?: string
   error?: string
+  /** Git worktree path (forked tasks) */
+  worktree?: string
+  /** Git branch name (forked tasks) */
+  branch?: string
+  /** Created PR URL (if requested) */
+  prUrl?: string
   abortController: AbortController
 }
 
@@ -39,6 +48,7 @@ export class BackgroundAgentRegistry {
     description: string,
     agentType: string,
     executor: (signal: AbortSignal) => Promise<string>,
+    kind: BackgroundTaskKind = 'interactive',
   ): string {
     const id = `bg-${++this.idCounter}-${Date.now().toString(36)}`
 
@@ -47,6 +57,7 @@ export class BackgroundAgentRegistry {
       description,
       agentType,
       status: 'running',
+      kind,
       startedAt: new Date(),
       abortController: new AbortController(),
     }

package/src/agent-view/agent-view-manager.ts

@@ -13,10 +13,13 @@ export interface SessionMessage {
   content: string
 }
 
+export type SessionKind = 'interactive' | 'forked' | 'attached' | 'unattended'
+
 export interface AgentSession {
   id: string
   title: string
   status: SessionStatus
+  kind: SessionKind
   provider: string
   model: string
   task: string
@@ -25,6 +28,12 @@ export interface AgentSession {
   completedAt?: Date
   elapsedMs: number
   messages: SessionMessage[]
+  /** Git worktree path (forked sessions) */
+  worktree?: string
+  /** Git branch name (forked sessions) */
+  branch?: string
+  /** Created PR URL (if requested) */
+  prUrl?: string
 }
 
 export interface CreateSessionOptions {
@@ -53,6 +62,7 @@ export class AgentViewManager {
       id,
       title,
       status: 'needs-input',
+      kind: 'interactive',
       provider: options.provider ?? 'unknown',
       model: options.model ?? 'unknown',
       task,

package/src/artifacts/server.ts

@@ -5,6 +5,7 @@ import { ARTIFACT_ALLOWED_EXTENSIONS } from '../shared/constants'
 import { readManifest } from './manifest'
 import { ArtifactVersioning } from './versioning'
 import type { ArtifactEntry } from '../shared/types'
+import { getMetrics } from '../core/metrics'
 
 // ── SSE client tracking ──
 interface SseClient {
@@ -151,10 +152,48 @@ export class ArtifactServer {
       return
     }
 
+    // Metrics endpoint — Prometheus text format
+    if (urlPath === '/metrics') {
+      this.serveMetrics(res, 'prometheus')
+      return
+    }
+
+    // Metrics endpoint — JSON format
+    if (urlPath === '/metrics/json') {
+      this.serveMetrics(res, 'json')
+      return
+    }
+
     // Artifact file
     this.serveArtifact(urlPath, res)
   }
 
+  // ── Metrics ──
+
+  private serveMetrics(res: any, format: 'prometheus' | 'json'): void {
+    try {
+      const metrics = getMetrics()
+      if (format === 'json') {
+        const body = JSON.stringify(metrics.toJSON(), null, 2)
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        })
+        res.end(body)
+      } else {
+        const body = metrics.toPrometheusText()
+        res.writeHead(200, {
+          'Content-Type': 'text/plain; charset=utf-8',
+          'Access-Control-Allow-Origin': '*',
+        })
+        res.end(body)
+      }
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' })
+      res.end(`Metrics error: ${err instanceof Error ? err.message : 'unknown'}`)
+    }
+  }
+
   // ── SSE ──
 
   private handleSse(res: any): void {

package/src/config/defaults.ts

@@ -1,4 +1,9 @@
-import type { MiphamConfig } from '../shared/index.ts'
+import type {
+  MiphamConfig,
+  InferenceHookConfig,
+  CredentialMaskingConfig,
+  BackgroundAgentConfig,
+} from '../shared/index.ts'
 import { DEFAULT_PROVIDERS } from '../shared/index.ts'
 import { PACKAGE_VERSION } from '../shared/index.ts'
 
@@ -9,3 +14,32 @@ export const DEFAULT_CONFIG: MiphamConfig = {
   permission: 'auto',
   providers: DEFAULT_PROVIDERS,
 }
+
+export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {
+  endpoint: '',
+  signing_secret: '',
+  timeout: 5000,
+  on_failure: 'fail-closed',
+  organization_id: '',
+  headers: {},
+}
+
+export const DEFAULT_CREDENTIAL_MASKING_CONFIG: CredentialMaskingConfig = {
+  enabled: true,
+  files: [],
+  output_scrubbing: {
+    enabled: true,
+    patterns: ['(?i)(api[_-]?key|secret|token|password|credential)\\s*[:=]\\s*\\S+'],
+  },
+  env_filter: {
+    enabled: true,
+    patterns: ['(?i)(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH)$'],
+  },
+}
+
+export const DEFAULT_BACKGROUND_AGENT_CONFIG: BackgroundAgentConfig = {
+  auto_commit: true,
+  auto_push: true,
+  auto_worktree: true,
+  commit_coauthors: true,
+}

package/src/config/loader.ts

@@ -10,8 +10,20 @@ import {
 import { join, dirname } from 'node:path'
 import { homedir } from 'node:os'
 import { parse as parseYaml } from 'yaml'
-import type { MiphamConfig, ProviderConfig, McpServerConfig } from '../shared/index.ts'
-import { DEFAULT_CONFIG } from './defaults'
+import type {
+  MiphamConfig,
+  ProviderConfig,
+  McpServerConfig,
+  InferenceHookConfig,
+  CredentialMaskingConfig,
+  BackgroundAgentConfig,
+} from '../shared/index.ts'
+import {
+  DEFAULT_CONFIG,
+  DEFAULT_INFERENCE_HOOK_CONFIG,
+  DEFAULT_CREDENTIAL_MASKING_CONFIG,
+  DEFAULT_BACKGROUND_AGENT_CONFIG,
+} from './defaults'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const BACKUP_PREFIX = 'config.backup-'
@@ -256,3 +268,111 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
 
   return config
 }
+
+/**
+ * Load inference hooks (DLP) configuration from the same config sources
+ * as the main config. Merges project-level over user-level.
+ *
+ * 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')
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+
+  let merged = { ...DEFAULT_INFERENCE_HOOK_CONFIG }
+
+  const paths = [userConfigPath, configPath] // project wins (loaded last)
+  for (const path of paths) {
+    try {
+      if (!existsSync(path)) continue
+      const raw = readFileSync(path, 'utf-8')
+      const parsed = parseYaml(raw) as Record<string, unknown>
+      const section = parsed.inference_hooks as Partial<InferenceHookConfig> | undefined
+      if (section) {
+        merged = {
+          endpoint: section.endpoint ?? merged.endpoint,
+          signing_secret: section.signing_secret ?? merged.signing_secret,
+          timeout: section.timeout ?? merged.timeout,
+          on_failure: section.on_failure ?? merged.on_failure,
+          organization_id: section.organization_id ?? merged.organization_id,
+          headers: { ...merged.headers, ...(section.headers || {}) },
+        }
+      }
+    } catch {
+      // Silently skip malformed configs — main loadConfig already warns
+    }
+  }
+
+  return merged
+}
+
+/**
+ * Load credential masking configuration from the same config sources.
+ * Merges project-level over user-level. Returns defaults if no section present.
+ */
+export function loadCredentialMaskingConfig(cwd: string = process.cwd()): CredentialMaskingConfig {
+  const configPath = join(cwd, '.mipham', 'config.yml')
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+
+  let merged = { ...DEFAULT_CREDENTIAL_MASKING_CONFIG }
+
+  const paths = [userConfigPath, configPath] // project wins (loaded last)
+  for (const path of paths) {
+    try {
+      if (!existsSync(path)) continue
+      const raw = readFileSync(path, 'utf-8')
+      const parsed = parseYaml(raw) as Record<string, unknown>
+      const section = parsed.credential_masking as Partial<CredentialMaskingConfig> | undefined
+      if (section) {
+        merged = {
+          enabled: section.enabled ?? merged.enabled,
+          files: section.files ?? merged.files,
+          output_scrubbing: {
+            enabled: section.output_scrubbing?.enabled ?? merged.output_scrubbing.enabled,
+            patterns: section.output_scrubbing?.patterns ?? merged.output_scrubbing.patterns,
+          },
+          env_filter: {
+            enabled: section.env_filter?.enabled ?? merged.env_filter.enabled,
+            patterns: section.env_filter?.patterns ?? merged.env_filter.patterns,
+          },
+        }
+      }
+    } catch {
+      // Silently skip malformed configs
+    }
+  }
+
+  return merged
+}
+
+/**
+ * Load background agent configuration from config sources.
+ */
+export function loadBackgroundAgentConfig(cwd: string = process.cwd()): BackgroundAgentConfig {
+  const configPath = join(cwd, '.mipham', 'config.yml')
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+
+  let merged = { ...DEFAULT_BACKGROUND_AGENT_CONFIG }
+
+  const paths = [userConfigPath, configPath]
+  for (const path of paths) {
+    try {
+      if (!existsSync(path)) continue
+      const raw = readFileSync(path, 'utf-8')
+      const parsed = parseYaml(raw) as Record<string, unknown>
+      const section = parsed.background_agent as Partial<BackgroundAgentConfig> | undefined
+      if (section) {
+        merged = {
+          auto_commit: section.auto_commit ?? merged.auto_commit,
+          auto_push: section.auto_push ?? merged.auto_push,
+          auto_worktree: section.auto_worktree ?? merged.auto_worktree,
+          commit_coauthors: section.commit_coauthors ?? merged.commit_coauthors,
+        }
+      }
+    } catch {
+      // Silently skip malformed configs
+    }
+  }
+
+  return merged
+}

package/src/core/credential-masker.ts

@@ -0,0 +1,203 @@
+import { relative, isAbsolute } from 'node:path'
+import { homedir } from 'node:os'
+import type { CredentialMaskingConfig, CredentialFileRule } from '../shared/index.ts'
+
+/** Sentinel value used to replace masked credentials. */
+export const CREDENTIAL_SENTINEL = '__MIPHAM_CREDENTIAL_MASKED__'
+
+/**
+ * Check if a file path matches any credential file rule.
+ * Returns the matching rule, or null if no match.
+ */
+export function matchCredentialFile(
+  filePath: string,
+  config: CredentialMaskingConfig,
+): CredentialFileRule | null {
+  if (!config.enabled || config.files.length === 0) return null
+
+  const expanded = expandHome(filePath)
+  for (const rule of config.files) {
+    if (matchPath(expanded, rule.path)) {
+      return rule
+    }
+  }
+  return null
+}
+
+/**
+ * Apply credential masking to file content.
+ * - 'full' mode: return sentinel value only
+ * - 'extract' mode: replace regex-matched tokens with sentinel
+ */
+export function maskContent(content: string, rule: CredentialFileRule): string {
+  if (rule.mode === 'full') {
+    return CREDENTIAL_SENTINEL
+  }
+
+  // extract mode
+  let masked = content
+  for (const extractRule of rule.extract) {
+    const replacement = extractRule.replacement || CREDENTIAL_SENTINEL
+    try {
+      const regex = new RegExp(extractRule.pattern, 'gm')
+      masked = masked.replace(regex, replacement)
+    } catch {
+      // Invalid regex — skip this rule silently
+    }
+  }
+  return masked
+}
+
+/**
+ * Scrub credential patterns from stdout/stderr output.
+ * Uses the configured output_scrubbing patterns to detect and replace
+ * credentials that may have leaked into command output.
+ */
+export function maskOutput(output: string, config: CredentialMaskingConfig): string {
+  if (!config.enabled || !config.output_scrubbing.enabled) return output
+
+  let masked = output
+  for (const pattern of config.output_scrubbing.patterns) {
+    try {
+      // Strip (?i) inline flags — JS uses the 'i' flag instead
+      const clean = pattern.replace(/^\(\?i\)/, '')
+      const regex = new RegExp(clean, 'gim')
+      masked = masked.replace(regex, (match) => {
+        // Replace everything after the separator (= or :)
+        return match.replace(/\s*[:=]\s*\S+/, `=${CREDENTIAL_SENTINEL}`)
+      })
+    } catch {
+      // Invalid regex — skip
+    }
+  }
+  return masked
+}
+
+/**
+ * Filter sensitive environment variables before spawning a subprocess.
+ * Returns a sanitized copy of process.env with matching vars removed.
+ */
+export function filterEnv(
+  env: Record<string, string | undefined>,
+  config: CredentialMaskingConfig,
+): Record<string, string | undefined> {
+  if (!config.enabled || !config.env_filter.enabled) return { ...env }
+
+  const filtered: Record<string, string | undefined> = {}
+  for (const [key, value] of Object.entries(env)) {
+    let blocked = false
+    for (const pattern of config.env_filter.patterns) {
+      try {
+        // Strip (?i) inline flags — JS uses the 'i' flag instead
+        const clean = pattern.replace(/^\(\?i\)/, '')
+        const regex = new RegExp(clean, 'i')
+        if (regex.test(key)) {
+          blocked = true
+          break
+        }
+      } catch {
+        // Invalid regex — skip
+      }
+    }
+    if (blocked) {
+      // Replace with sentinel so tools can detect they're filtered
+      filtered[key] = CREDENTIAL_SENTINEL
+    } else {
+      filtered[key] = value
+    }
+  }
+
+  return filtered
+}
+
+/**
+ * Get the file display name for a sentinel value (for model visibility).
+ * The model sees the sentinel, doesn't know the original file path.
+ */
+export function getSentinelDisplay(hint?: string): string {
+  if (hint) {
+    return `[Credential file masked: ${hint}]`
+  }
+  return CREDENTIAL_SENTINEL
+}
+
+// ── Internal helpers ──
+
+/**
+ * Expand ~ to the user's home directory.
+ */
+function expandHome(p: string): string {
+  if (p.startsWith('~')) {
+    return homedir() + p.slice(1)
+  }
+  return p
+}
+
+/**
+ * Match a file path against a glob-like pattern.
+ * Supports:
+ * - ** globstar (matches any number of path segments)
+ * - * wildcard within a single path segment
+ * - ~ home directory expansion
+ * - basename-only matching (e.g. ".env*" matches any .env file)
+ */
+function matchPath(filePath: string, pattern: string): boolean {
+  const expandedPattern = expandHome(pattern)
+  const normalizedFile = filePath.replace(/\\/g, '/')
+  const normalizedPattern = expandedPattern.replace(/\\/g, '/')
+
+  // Exact match
+  if (normalizedFile === normalizedPattern) {
+    return true
+  }
+
+  // File ends with pattern (for relative basename matching like ".env*")
+  if (normalizedFile.endsWith('/' + normalizedPattern)) {
+    return true
+  }
+
+  // Convert glob pattern to regex
+  const regex = globToRegex(normalizedPattern)
+  return regex.test(normalizedFile)
+}
+
+/**
+ * Convert a glob pattern to a RegExp.
+ * - ** → .* (matches any path segments)
+ * - *  → [^/]* (matches within a single segment)
+ * - ?  → . (single char)
+ * - All other special regex chars are escaped.
+ */
+function globToRegex(pattern: string): RegExp {
+  let regexStr = ''
+  let i = 0
+  while (i < pattern.length) {
+    const ch = pattern[i]!
+    if (ch === '*' && pattern[i + 1] === '*') {
+      // ** — match zero or more path segments
+      regexStr += '.*'
+      i += 2
+      // Skip trailing slash after **
+      if (pattern[i] === '/') i++
+      continue
+    }
+    if (ch === '*') {
+      regexStr += '[^/]*'
+      i++
+      continue
+    }
+    if (ch === '?') {
+      regexStr += '.'
+      i++
+      continue
+    }
+    // Escape regex special chars
+    if ('\\^$.|+()[]{}'.includes(ch)) {
+      regexStr += '\\' + ch
+    } else {
+      regexStr += ch
+    }
+    i++
+  }
+  return new RegExp('^' + regexStr + '$')
+}

package/src/core/engine.ts

@@ -1,4 +1,9 @@
-import type { StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
+import type {
+  StreamChunk,
+  ToolDefinition,
+  ToolResult,
+  InferenceHookConfig,
+} from '../shared/index.ts'
 import { ProviderRegistry } from '../providers/registry'
 import { ContextManager } from './context'
 import { PermissionSystem } from './permission'
@@ -11,6 +16,7 @@ import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import type { SkillsLoader } from '../skills/loader'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
 import { RulesLoader } from './rules-loader'
+import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 
 export class QueryEngine {
   private hookEngine?: HookEngine
@@ -76,6 +82,8 @@ export class QueryEngine {
   private rulesLoader?: RulesLoader
   /** Files touched in the current turn (for rules matching). */
   private touchedFiles: Set<string> = new Set()
+  /** Inference hook (DLP) configuration. */
+  private inferenceHookConfig?: InferenceHookConfig
 
   /** Register the rules loader. */
   setRulesLoader(loader: RulesLoader): void {
@@ -83,6 +91,11 @@ export class QueryEngine {
     this.rulesLoader.load()
   }
 
+  /** Register inference hook (DLP) configuration. */
+  setInferenceHookConfig(config: InferenceHookConfig): void {
+    this.inferenceHookConfig = config
+  }
+
   /** Pending task notifications from background agents (cleared after draining). */
   private pendingTaskNotifications: Array<StreamChunk> = []
 
@@ -256,6 +269,27 @@ export class QueryEngine {
     const messages = this.context.getMessages()
     const toolDefs = this.getToolDefinitions()
 
+    // ── PreInference DLP checkpoint ──
+    if (isInferenceHookEnabled(this.inferenceHookConfig)) {
+      const provider = this.registry.getActive().config.id
+      const model = this.registry.getActiveModel()
+      const request = buildRequest(
+        messages,
+        'session-1',
+        provider,
+        model,
+        this.inferenceHookConfig!.organization_id,
+      )
+      const verdict = await sendInferenceCheck(this.inferenceHookConfig!, request)
+      if (!verdict.allowed) {
+        yield {
+          type: 'error',
+          error: verdict.reason || 'Request blocked by DLP policy.',
+        }
+        return
+      }
+    }
+
     let assistantContent = ''
     let reasoningContent = ''
     let thinkingContent = ''
@@ -481,6 +515,27 @@ export class QueryEngine {
       const systemPrompt = this.context.getSystemPrompt()
       const messages = this.context.getMessages()
 
+      // ── PreInference DLP checkpoint (every tool-calling turn) ──
+      if (isInferenceHookEnabled(this.inferenceHookConfig)) {
+        const provider = this.registry.getActive().config.id
+        const model = this.registry.getActiveModel()
+        const request = buildRequest(
+          messages,
+          'session-1',
+          provider,
+          model,
+          this.inferenceHookConfig!.organization_id,
+        )
+        const verdict = await sendInferenceCheck(this.inferenceHookConfig!, request)
+        if (!verdict.allowed) {
+          yield {
+            type: 'error',
+            error: verdict.reason || 'Request blocked by DLP policy.',
+          }
+          return
+        }
+      }
+
       let assistantContent = ''
       let reasoningContent = ''
       let thinkingContent = ''

package/src/core/hooks.ts

@@ -155,6 +155,29 @@ export class HookEngine {
     return this.runHooks('PostToolUseFailure', toolName, ctx)
   }
 
+  /** PreInference: fires before every model API call for DLP inspection. */
+  async executePreInference(
+    messages: Array<{ role: string; content: string }>,
+    toolCalls: Array<{
+      name: string
+      input: Record<string, unknown>
+      resultPreview: string
+    }>,
+    sessionId: string,
+    provider: string,
+    model: string,
+  ): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'PreInference',
+      sessionId,
+      messages,
+      toolCalls,
+      provider,
+      model,
+    }
+    return this.runHooks('PreInference', undefined, ctx)
+  }
+
   // ── Core execution ──
 
   private async runHooks(