@miphamai/cli 0.20.0 → 0.20.2

package/package.json

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

package/src/agent/sub-agent.ts

@@ -271,8 +271,10 @@ export class SubAgent {
             continue
           }
 
-          // Security: check permission before executing
-          // Sub-agents run without user interaction — tools requiring approval are rejected
+          // Security: check permission before executing.
+          // Sub-agents run without user interaction — tools requiring approval are rejected.
+          // When permission system is absent (undefined), allow all tools (backward compat
+          // for tests and headless usage). When present, always enforce approval checks.
           if (this.permission?.needsApproval(tool, tu.input)) {
             currentMessages.push({
               role: 'user' as const,

package/src/core/engine.ts

@@ -18,10 +18,10 @@ import { getBackgroundAgentRegistry } from '../agent/background-registry'
 import { RulesLoader } from './rules-loader'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
-import { createT } from '@mipham/shared/i18n/t'
-import enUS from '@mipham/shared/i18n/locales/en-US.json'
-import zhCN from '@mipham/shared/i18n/locales/zh-CN.json'
-import type { TranslationMap } from '@mipham/shared/i18n/types'
+import { createT } from '../i18n-core/t'
+import enUS from '../i18n-core/locales/en-US.json'
+import zhCN from '../i18n-core/locales/zh-CN.json'
+import type { TranslationMap } from '../i18n-core/types'
 
 const bundles: Record<string, TranslationMap> = {
   'en-US': enUS as TranslationMap,
@@ -516,9 +516,9 @@ export class QueryEngine {
         }
         // Script failed — continue looping
         yield {
-            type: 'text',
-            content: t('system.goal.failed_continuing', { loop: String(loop) }),
-          }
+          type: 'text',
+          content: t('system.goal.failed_continuing', { loop: String(loop) }),
+        }
         continue
       }
 
@@ -561,11 +561,14 @@ export class QueryEngine {
   private async runScriptVerification(): Promise<boolean> {
     if (!this.goalVerifyScript) return false
     try {
-      const { execSync } = await import('node:child_process')
-      execSync(this.goalVerifyScript, { timeout: 30000, stdio: 'pipe' })
-      return true // exit code 0 = success
+      const { spawnSync } = await import('node:child_process')
+      const { resolveSafe } = await import('../security/path')
+      // Validate the script path is within the workspace before execution
+      const safePath = resolveSafe(process.cwd(), this.goalVerifyScript)
+      const result = spawnSync(safePath, [], { timeout: 30000, stdio: 'pipe' })
+      return result.status === 0 // exit code 0 = success
     } catch {
-      return false // non-zero exit = not yet achieved
+      return false // non-zero exit or path rejection = not yet achieved
     }
   }
 
@@ -797,7 +800,11 @@ export class QueryEngine {
 
       return result
     } catch (err) {
-      return { success: false, content: '', error: String(err) }
+      // Sanitize error: strip stack traces and internal paths to prevent
+      // information disclosure to the LLM conversation context.
+      const message =
+        err instanceof Error ? err.message : String(err).split('\n')[0] || 'Unknown error'
+      return { success: false, content: '', error: `Tool execution failed: ${message}` }
     }
   }
 

package/src/core/hooks-executor.ts

@@ -1,4 +1,4 @@
-import { execSync } from 'node:child_process'
+import { spawnSync } from 'node:child_process'
 import type { HookConfig, HookContext, HookResult } from '../shared/index.ts'
 
 /**
@@ -36,21 +36,22 @@ function executeCommand(cfg: HookConfig, ctx: HookContext): HookResult {
   try {
     const args = cfg.args ? cfg.args.map((a) => substituteVars(a, ctx)) : []
 
-    const cmd = [cfg.command, ...args].join(' ')
-
-    execSync(cmd, {
+    // Use spawnSync with array args — no shell, no command injection
+    const result = spawnSync(cfg.command, args, {
       timeout: 30_000,
       encoding: 'utf-8',
       stdio: ['ignore', 'pipe', 'pipe'],
     })
 
     // Exit code 0 = success, allow
-    return { allowed: true }
-  } catch (err) {
-    const stderr = (err as { stderr?: string }).stderr || String(err)
+    if (result.status === 0) {
+      return { allowed: true }
+    }
+
+    // Non-zero exit: check for block signal (exit code 2)
+    const stderr = result.stderr?.toString() || ''
 
-    // Exit code 2 = block with reason
-    if ((err as { status?: number }).status === 2) {
+    if (result.status === 2) {
       return {
         allowed: false,
         reason: stderr.trim() || 'Blocked by hook',
@@ -63,6 +64,15 @@ function executeCommand(cfg: HookConfig, ctx: HookContext): HookResult {
       allowed: true,
       additionalContext: `Hook warning (${cfg.command}): ${stderr.trim()}`,
     }
+  } catch (err) {
+    // spawnSync errors (e.g., command not found, timeout, signal)
+    const message = (err as { message?: string }).message || String(err)
+
+    // Timeout/signal: treat as non-blocking warning
+    return {
+      allowed: true,
+      additionalContext: `Hook error (${cfg.command}): ${message}`,
+    }
   }
 }
 

package/src/i18n-context.tsx

@@ -1,5 +1,5 @@
 import React, { createContext, useContext } from 'react'
-import type { Locale } from '@mipham/shared/i18n/types'
+import type { Locale } from './i18n-core/types'
 
 export interface I18nContextValue {
   locale: Locale
@@ -17,11 +17,7 @@ export function I18nProvider({
   t: (key: string, params?: Record<string, string>) => string
   children: React.ReactNode
 }) {
-  return React.createElement(
-    I18nContext.Provider,
-    { value: { locale, t } },
-    children,
-  )
+  return React.createElement(I18nContext.Provider, { value: { locale, t } }, children)
 }
 
 export function useI18n(): I18nContextValue {

package/src/i18n-core/detect.ts

@@ -0,0 +1,54 @@
+import type { Locale } from './types'
+import { execSync } from 'node:child_process'
+
+export function detectLocale(opts?: { lang?: string; cwd?: string }): Locale {
+  // 1. CLI --lang flag
+  if (opts?.lang) {
+    const normalized = normalizeLocale(opts.lang)
+    if (normalized) return normalized as Locale
+  }
+
+  // 2. LANG / LC_ALL env vars
+  const langEnv = process.env.LC_ALL || process.env.LANG || ''
+  const envLocale = parseLangEnv(langEnv)
+  if (envLocale) return envLocale
+
+  // 3. OS detection
+  const osLocale = detectOSLocale()
+  if (osLocale) return osLocale
+
+  // 4. Fallback
+  return 'en-US'
+}
+
+function normalizeLocale(raw: string): string | null {
+  const lower = raw.toLowerCase().replace('_', '-')
+  if (lower.startsWith('zh')) return 'zh-CN'
+  if (lower.startsWith('en')) return 'en-US'
+  return null
+}
+
+function parseLangEnv(env: string): Locale | null {
+  if (!env || env === 'C' || env === 'POSIX') return null
+  return normalizeLocale(env) as Locale | null
+}
+
+function detectOSLocale(): Locale | null {
+  try {
+    if (process.platform === 'darwin') {
+      const out = execSync('defaults read -g AppleLocale 2>/dev/null', {
+        encoding: 'utf-8',
+        timeout: 1000,
+      }).trim()
+      return normalizeLocale(out) as Locale | null
+    }
+    if (process.platform === 'win32') {
+      // Use Intl as fallback — the kernel32 approach is too complex for startup
+      return normalizeLocale(Intl.DateTimeFormat().resolvedOptions().locale) as Locale | null
+    }
+    // Linux: try LANG env one more time, then Intl
+    return normalizeLocale(Intl.DateTimeFormat().resolvedOptions().locale) as Locale | null
+  } catch {
+    return null
+  }
+}