@miphamai/cli 0.36.0 → 0.36.2

package/package.json

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

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

@@ -34,11 +34,14 @@ export interface AgentSession {
   branch?: string
   /** Created PR URL (if requested) */
   prUrl?: string
+  /** Working directory the session was spawned from (used for directory grouping). */
+  directory: string
 }
 
 export interface CreateSessionOptions {
   provider?: string
   model?: string
+  directory?: string
 }
 
 export interface SessionPeek {
@@ -48,6 +51,11 @@ export interface SessionPeek {
 
 export type StatusGroups = Record<SessionStatus, AgentSession[]>
 
+export interface DirectoryGroup {
+  directory: string
+  sessions: AgentSession[]
+}
+
 export class AgentViewManager {
   private sessions: Map<string, AgentSession> = new Map()
   private sessionOrder: string[] = []
@@ -66,6 +74,7 @@ export class AgentViewManager {
       provider: options.provider ?? 'unknown',
       model: options.model ?? 'unknown',
       task,
+      directory: options.directory ?? process.cwd(),
       createdAt: new Date(),
       elapsedMs: 0,
       messages: [],
@@ -109,6 +118,27 @@ export class AgentViewManager {
     return groups
   }
 
+  /**
+   * Group all sessions by their working directory (v2.1.229 session-grouping alignment).
+   * Returns groups sorted alphabetically by directory path.
+   */
+  groupByDirectory(): DirectoryGroup[] {
+    const groups = new Map<string, AgentSession[]>()
+
+    for (const id of this.sessionOrder) {
+      const session = this.sessions.get(id)
+      if (!session) continue
+      const dir = session.directory || '(unknown)'
+      const existing = groups.get(dir)
+      if (existing) existing.push(session)
+      else groups.set(dir, [session])
+    }
+
+    return Array.from(groups.entries())
+      .map(([directory, sessions]) => ({ directory, sessions }))
+      .sort((a, b) => a.directory.localeCompare(b.directory))
+  }
+
   /**
    * Get a session by ID.
    */

package/src/agent-view/dashboard.tsx

@@ -30,7 +30,7 @@ const STATUS_HEADERS: Record<string, { label: string; color: string }> = {
 export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps) {
   const [selectedIndex, setSelectedIndex] = useState(0)
   const [peekingSessionId, setPeekingSessionId] = useState<string | null>(null)
-  const [_groupBy, setGroupBy] = useState<'status' | 'directory'>('status')
+  const [groupBy, setGroupBy] = useState<'status' | 'directory'>('status')
   const [feedback, setFeedback] = useState<string | null>(null)
 
   // Flash a brief feedback message that auto-clears
@@ -41,37 +41,53 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
 
   // Build a flat list of sessions in group order, with group headers
   const flatList = useMemo(() => {
-    const groups = manager.groupByStatus()
     const result: Array<
-      | { type: 'header'; status: string; label: string; color: string; count: number }
+      | { type: 'header'; key: string; label: string; color: string; count: number }
       | { type: 'session'; session: AgentSession }
     > = []
 
-    const statusOrder: Array<keyof typeof STATUS_HEADERS> = [
-      'working',
-      'needs-input',
-      'completed',
-      'failed',
-    ]
+    if (groupBy === 'directory') {
+      for (const group of manager.groupByDirectory()) {
+        result.push({
+          type: 'header',
+          key: `dir-${group.directory}`,
+          label: group.directory,
+          color: 'blue',
+          count: group.sessions.length,
+        })
 
-    for (const _status of statusOrder) {
-      const status = _status as SessionStatus
-      const sessions = groups[status] ?? []
-      result.push({
-        type: 'header',
-        status,
-        label: STATUS_HEADERS[status]!.label,
-        color: STATUS_HEADERS[status]!.color,
-        count: sessions.length,
-      })
+        for (const session of group.sessions) {
+          result.push({ type: 'session', session })
+        }
+      }
+    } else {
+      const groups = manager.groupByStatus()
+      const statusOrder: Array<keyof typeof STATUS_HEADERS> = [
+        'working',
+        'needs-input',
+        'completed',
+        'failed',
+      ]
+
+      for (const _status of statusOrder) {
+        const status = _status as SessionStatus
+        const sessions = groups[status] ?? []
+        result.push({
+          type: 'header',
+          key: `status-${status}`,
+          label: STATUS_HEADERS[status]!.label,
+          color: STATUS_HEADERS[status]!.color,
+          count: sessions.length,
+        })
 
-      for (const session of sessions) {
-        result.push({ type: 'session', session })
+        for (const session of sessions) {
+          result.push({ type: 'session', session })
+        }
       }
     }
 
     return result
-  }, [manager])
+  }, [manager, groupBy])
 
   // Flatten sessions only for navigation (skip headers)
   const sessionsOnly = useMemo(
@@ -106,7 +122,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
     // Ctrl+T — toggle group by (status ↔ directory)
     if (key.ctrl && input === 't') {
       setGroupBy((prev) => (prev === 'status' ? 'directory' : 'status'))
-      showFeedback(`Grouped by ${_groupBy === 'status' ? 'directory' : 'status'}`)
+      showFeedback(`Grouped by ${groupBy === 'status' ? 'directory' : 'status'}`)
       return
     }
 
@@ -238,7 +254,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
           {flatList.map((item, _flatIdx) => {
             if (item.type === 'header') {
               return (
-                <Box key={`h-${item.status}`} marginY={1}>
+                <Box key={`h-${item.key}`} marginY={1}>
                   <Text bold color={item.color}>
                     {' '}
                     {item.label} ({item.count})

package/src/core/engine.ts

@@ -377,6 +377,10 @@ export class QueryEngine {
   }
 
   async *process(userInput: string, signal?: AbortSignal): AsyncGenerator<StreamChunk> {
+    // v2.1.229 alignment: reject whitespace-only messages before they reach the
+    // provider API (which would otherwise 400 on an empty/blank message).
+    if (!userInput.trim()) return
+
     // Poll for cross-session messages before each turn
     await this.pollCrossSessionInbox()
 
@@ -442,13 +446,12 @@ export class QueryEngine {
 
     // Stream model response
     try {
-      for await (const chunk of this.registry.chat({
-        model: this.registry.getActiveModel(),
+      for await (const chunk of this.chatWithFallback(
         messages,
         systemPrompt,
-        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        toolDefs.length > 0 ? toolDefs : undefined,
         signal,
-      })) {
+      )) {
         yield chunk
 
         if (chunk.type === 'error') {
@@ -1140,6 +1143,80 @@ export class QueryEngine {
     return this.registry
   }
 
+  /**
+   * Stream a chat response with graceful provider fallback (v2.1.229 alignment).
+   *
+   * On a connection/availability failure from the active provider (thrown
+   * network error or an error chunk), switches to the configured default
+   * provider and retries once, yielding a `warning` chunk so the UI can tell
+   * the user the provider degraded. Abort errors propagate untouched.
+   */
+  private async *chatWithFallback(
+    messages: import('../shared/types').Message[],
+    systemPrompt: string,
+    toolDefs: Record<string, unknown>[] | undefined,
+    signal?: AbortSignal,
+  ): AsyncGenerator<StreamChunk> {
+    const activeId = this.registry.getActive().config.id
+    const defaultId = this.registry.getDefaultProviderId()
+
+    // ── Attempt 1: active provider ──
+    let failure: string | null = null
+    try {
+      for await (const chunk of this.registry.chat({
+        model: this.registry.getActiveModel(),
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        signal,
+      })) {
+        if (chunk.type === 'error') {
+          failure = chunk.error ?? 'Unknown error'
+          break
+        }
+        yield chunk
+      }
+      if (failure === null) return
+    } catch (err) {
+      if (isAbortError(err)) throw err
+      failure = String(err)
+    }
+
+    // ── Fallback: configured default provider, once ──
+    if (!defaultId || defaultId === activeId || !this.registry.get(defaultId)) {
+      yield { type: 'error', error: failure }
+      return
+    }
+    const fallbackModel = this.registry
+      .get(defaultId)!
+      .config.models.find((m) => m.status === 'active')?.id
+    if (!fallbackModel) {
+      yield { type: 'error', error: failure }
+      return
+    }
+
+    this.registry.switchProvider(defaultId, fallbackModel)
+    yield {
+      type: 'warning',
+      content: `${activeId} unreachable — degraded to ${defaultId} (${fallbackModel})`,
+    }
+
+    try {
+      for await (const chunk of this.registry.chat({
+        model: fallbackModel,
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        signal,
+      })) {
+        yield chunk
+      }
+    } catch (err) {
+      if (isAbortError(err)) throw err
+      yield { type: 'error', error: String(err) }
+    }
+  }
+
   getTools(): Map<string, ToolDefinition> {
     return this.tools
   }

package/src/core/permission.ts

@@ -9,6 +9,18 @@ import type { PermissionRuleEntry } from '../shared/index.ts'
 import { matchBashRule, compileRule } from './permission-rules'
 import { loadPermissionConfig, nextMode, clampMode, MODE_CYCLE } from './permission-config'
 
+/**
+ * Check if a Bash command is a git/gh operation using a destructive flag
+ * (--force, --amend, --no-verify, --hard) that must never be auto-approved.
+ * v2.1.229 alignment: these rewrite history / force-push, so they fall back
+ * to explicit user confirmation even in auto mode.
+ */
+function hasDangerousGitFlags(input: Record<string, unknown>): boolean {
+  const cmd = (input.command as string) || ''
+  if (!/^(git|gh)\s+/.test(cmd.trim())) return false
+  return /--force(?!-with-lease)\b|--amend\b|--no-verify\b|--hard\b/.test(cmd)
+}
+
 /**
  * Check if a Bash command is a "verification-only" command that should be
  * auto-approved in acceptEdits mode. These are non-destructive read/check
@@ -414,6 +426,10 @@ export class PermissionSystem {
         if (this.isSubAgent && ['Bash', 'Write', 'Edit'].includes(tool.name)) {
           return 'ask'
         }
+        // v2.1.229 alignment: destructive git/gh flags are never auto-approved.
+        if (tool.name === 'Bash' && input && hasDangerousGitFlags(input)) {
+          return 'ask'
+        }
         return 'bypass'
 
       case 'dontAsk':

package/src/providers/openai-compat.ts

@@ -8,9 +8,13 @@ export class OpenAICompatProvider implements ProviderInstance {
   constructor(public config: ProviderConfig) {}
 
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
-    // Accept both baseUrl and baseURL (common YAML typo)
+    // Accept both baseUrl and baseURL (common YAML typo); resolve env templates
     const rawBase = (this.config as any).baseUrl || (this.config as any).baseURL
-    const baseUrl = rawBase?.replace(/\/+$/, '') || 'https://api.openai.com/v1'
+    const baseUrl =
+      this.resolveEnvTemplate(
+        rawBase?.replace(/\/+$/, '') || '',
+        'OpenAI-compatible provider: baseUrl',
+      ) || 'https://api.openai.com/v1'
     const apiKey = this.resolveApiKey(this.config.apiKey)
 
     const body = {
@@ -224,11 +228,18 @@ export class OpenAICompatProvider implements ProviderInstance {
   async healthCheck(): Promise<boolean> {
     try {
       const rawBase = (this.config as any).baseUrl || (this.config as any).baseURL
-      const baseUrl = rawBase?.replace(/\/+$/, '') || 'https://api.openai.com/v1'
+      const baseUrl =
+        this.resolveEnvTemplate(
+          rawBase?.replace(/\/+$/, '') || '',
+          'OpenAI-compatible provider: baseUrl',
+        ) || 'https://api.openai.com/v1'
       const apiKey = this.resolveApiKey(this.config.apiKey)
-      const res = await fetch(`${baseUrl}/models`, {
-        headers: { Authorization: `Bearer ${apiKey}` },
-      })
+      // 5s timeout so a down endpoint doesn't hang health checks (v2.1.229 alignment)
+      const res = await fetchWithRetry(
+        `${baseUrl}/models`,
+        { headers: { Authorization: `Bearer ${apiKey}` } },
+        { timeout: 5000, maxRetries: 0 },
+      )
       return res.ok
     } catch {
       return false
@@ -366,21 +377,25 @@ export class OpenAICompatProvider implements ProviderInstance {
     }
   }
 
-  private resolveApiKey(keyTemplate: string): string {
-    // Accept both ${VAR} and $VAR syntax
-    let match = keyTemplate.match(/^\$\{(.+)\}$/)
-    if (!match) match = keyTemplate.match(/^\$([A-Z_][A-Z0-9_]*)$/)
+  /** Resolve a `${VAR}` / `$VAR` template against the environment. */
+  private resolveEnvTemplate(value: string, warnPrefix: string): string {
+    let match = value.match(/^\$\{(.+)\}$/)
+    if (!match) match = value.match(/^\$([A-Z_][A-Z0-9_]*)$/)
     if (match?.[1]) {
       const varName = match[1]
-      const value = process.env[varName]
-      if (!value) {
+      const envValue = process.env[varName]
+      if (!envValue) {
         process.stderr.write(
-          `⚠ OpenAI-compatible provider: apiKey references $${varName} but that environment variable is not set\n`,
+          `⚠ ${warnPrefix} references $${varName} but that environment variable is not set\n`,
         )
         return ''
       }
-      return value
+      return envValue
     }
-    return keyTemplate
+    return value
+  }
+
+  private resolveApiKey(keyTemplate: string): string {
+    return this.resolveEnvTemplate(keyTemplate, 'OpenAI-compatible provider: apiKey')
   }
 }

package/src/providers/registry.ts

@@ -21,10 +21,24 @@ export class ProviderRegistry {
   private providers = new Map<string, ProviderInstance>()
   private activeProviderId: string
   private activeModelId: string
+  private defaultProviderId: string
+  private defaultModelId: string
 
   constructor(providers: ProviderConfig[], defaultProvider: string, defaultModel: string) {
     this.activeProviderId = defaultProvider
     this.activeModelId = defaultModel
+    this.defaultProviderId = defaultProvider
+    this.defaultModelId = defaultModel
+  }
+
+  /** The configured default provider id (used for fallback routing). */
+  getDefaultProviderId(): string {
+    return this.defaultProviderId
+  }
+
+  /** The configured default model id. */
+  getDefaultModelId(): string {
+    return this.defaultModelId
   }
 
   register(id: string, instance: ProviderInstance): void {
@@ -72,6 +86,32 @@ export class ProviderRegistry {
     return undefined
   }
 
+  /**
+   * Check a single provider's health. Returns undefined if not registered,
+   * otherwise the provider's healthCheck() result. Never throws.
+   */
+  async healthStatus(id: string): Promise<boolean | undefined> {
+    const provider = this.providers.get(id)
+    if (!provider) return undefined
+    try {
+      return await provider.healthCheck()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Health of all registered providers, checked concurrently.
+   * Returns a Map of provider id → reachable boolean.
+   */
+  async healthMap(): Promise<Map<string, boolean>> {
+    const ids = this.listIds()
+    const results = await Promise.all(
+      ids.map(async (id) => [id, (await this.healthStatus(id)) ?? false] as const),
+    )
+    return new Map(results)
+  }
+
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
     const provider = this.getActive()
     yield* provider.chat({ ...req, model: req.model || this.activeModelId })

package/src/shared/types.ts

@@ -129,6 +129,7 @@ export interface StreamChunk {
     | 'thinking'
     | 'stop'
     | 'error'
+    | 'warning'
     | 'task_notification'
     | 'usage'
   content?: string

package/src/ui/app.tsx

@@ -658,6 +658,17 @@ export function App({
             ])
           }
 
+          if (chunk.type === 'warning' && chunk.content) {
+            setMessages((prev) => [...prev, { role: 'system', content: `⚠ ${chunk.content}` }])
+            // Keep the footer's provider/model in sync after an automatic fallback
+            // switch. RemoteEngine's registry is a stub without getActive.
+            const registry = engine.getRegistry()
+            if ('getActive' in registry) {
+              setProviderId(registry.getActive().config.id)
+              setModelId(registry.getActiveModel())
+            }
+          }
+
           if (chunk.type === 'task_notification' && chunk.taskNotification) {
             const tn = chunk.taskNotification
             const isDone = tn.status === 'completed'

package/src/ui/commands.ts

@@ -317,12 +317,20 @@ const contextCmd: CommandHandler = (ctx) => {
   }
 }
 
-const statusCmd: CommandHandler = (ctx) => {
+const statusCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const c = ctx.engine.getContext()
   const tools = ctx.engine.getTools()
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js'
   const runtimeVer = typeof Bun !== 'undefined' ? Bun.version : process.version
+  const health = ctx.engine.getRegistry()
+    ? await ctx.engine.getRegistry().healthMap()
+    : new Map<string, boolean>()
+  const providerHealth = ctx.config.providers
+    .filter((p) => p.status !== 'upcoming')
+    .map((p) => `${p.id} ${health.get(p.id) ? '🟢' : '🔴'}`)
+    .join('  ')
+
   return {
     content: stripIndent`
       ${t('commands.status.session_title')}
@@ -337,6 +345,9 @@ const statusCmd: CommandHandler = (ctx) => {
       ${t('commands.status.platform')}   ${process.platform} ${process.arch}
       ${t('commands.status.runtime')}    ${runtime} ${runtimeVer}
       ${t('commands.status.cwd')}        ${process.cwd()}
+
+      Providers
+      ${providerHealth}
     `,
   }
 }
@@ -449,12 +460,19 @@ const providerCmd: CommandHandler = (ctx) => {
   }
 }
 
-const providersCmd: CommandHandler = (ctx) => {
+const providersCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
-  const lines = ctx.config.providers.map(
-    (p) =>
-      `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ${p.status === 'upcoming' ? '[upcoming]' : '✓'}`,
-  )
+  const health = ctx.engine.getRegistry()
+    ? await ctx.engine.getRegistry().healthMap()
+    : new Map<string, boolean>()
+
+  const lines = ctx.config.providers.map((p) => {
+    if (p.status === 'upcoming') {
+      return `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ⏳ [upcoming]`
+    }
+    const ok = health.get(p.id) ?? false
+    return `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ${ok ? '🟢 reachable' : '🔴 unreachable'}`
+  })
   return {
     content: `${t('commands.providers.title')}\n\n${lines.join('\n')}\n\n${t('commands.providers.current', { provider: ctx.providerId, model: ctx.modelId })}`,
   }

package/src/workflow/primitives/parallel.ts

@@ -1,11 +1,29 @@
+import os from 'node:os'
+
 /**
  * parallel() — barrier: executes all thunks concurrently, waits for all.
  * Failed thunks resolve to null. Never throws.
  *
- * P0-2 (v2.1.223 alignment): Added concurrency cap (MAX_CONCURRENT = 16)
- * to prevent resource exhaustion from unbounded fan-out.
+ * P0-2 (v2.1.223 alignment): Added concurrency cap (MAX_CONCURRENT) to prevent
+ * resource exhaustion from unbounded fan-out.
+ *
+ * v2.1.229 alignment: detect parallelism via os.availableParallelism() so
+ * CPU-limited containers (cgroup quota) don't fan out to the host core count.
+ * Still capped at 16 to bound resource usage, with a floor of 1.
  */
-const MAX_CONCURRENT = 16
+function detectParallelism(): number {
+  try {
+    if (typeof os.availableParallelism === 'function') {
+      const p = os.availableParallelism()
+      if (typeof p === 'number' && p > 0) return p
+    }
+  } catch {
+    /* fall through to cpus() */
+  }
+  return os.cpus().length || 1
+}
+
+const MAX_CONCURRENT = Math.max(1, Math.min(16, detectParallelism()))
 
 /**
  * Simple async semaphore for concurrency limiting.