@miphamai/cli 0.2.4 → 0.4.0

package/src/core/engine.ts

@@ -1,9 +1,14 @@
-import type { Message, StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
+import type { StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
 import { ProviderRegistry } from '../providers/registry'
 import { ContextManager } from './context'
 import { PermissionSystem } from './permission'
+import type { HookEngine } from './hooks'
+import type { ArtifactServer } from '../artifacts/server'
 
 export class QueryEngine {
+  private hookEngine?: HookEngine
+  private artifactServer?: ArtifactServer
+
   constructor(
     private registry: ProviderRegistry,
     private context: ContextManager,
@@ -11,11 +16,60 @@ export class QueryEngine {
     private permission: PermissionSystem = new PermissionSystem('bypass'),
   ) {}
 
+  /** Register a hook engine for pre/post tool-use lifecycle events. */
+  setHookEngine(hooks: HookEngine): void {
+    this.hookEngine = hooks
+  }
+
+  /** Register the artifact server for tool context. */
+  setArtifactServer(server: ArtifactServer): void {
+    this.artifactServer = server
+  }
+
+  /** Wire LLM-based conversation summarization into the context manager. */
+  setupContextSummarizer(): void {
+    this.context.setSummarizer(async (messages, heading) => {
+      const text = messages
+        .map((m) => {
+          const role = m.role
+          const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content)
+          return `[${role}]: ${content.slice(0, 500)}`
+        })
+        .join('\n')
+
+      // Build a minimal system prompt for summarization
+      const summaryPrompt = `You are a conversation summarizer. Create a concise summary (1-3 paragraphs) of this conversation excerpt. Focus on: key topics discussed, decisions made, code changes mentioned, and open questions. Heading: ${heading}`
+
+      // Collect full summary text from streaming response
+      let summary = ''
+      try {
+        for await (const chunk of this.registry.chat({
+          model: this.registry.getActiveModel(),
+          messages: [
+            { role: 'system', content: summaryPrompt },
+            { role: 'user', content: text },
+          ],
+          maxTokens: 300,
+        })) {
+          if (chunk.type === 'text' && chunk.content) {
+            summary += chunk.content
+          }
+          if (chunk.type === 'stop') break
+          if (chunk.type === 'error') break
+        }
+      } catch {
+        // Return a minimal summary on failure
+      }
+
+      return summary.slice(0, 2000) || 'Prior conversation context omitted.'
+    })
+  }
+
   getPermission(): PermissionSystem {
     return this.permission
   }
 
-  async *process(userInput: string): AsyncGenerator<StreamChunk> {
+  async *process(userInput: string, signal?: AbortSignal): AsyncGenerator<StreamChunk> {
     // Add user message to context
     this.context.addMessage({ role: 'user', content: userInput })
 
@@ -32,37 +86,51 @@ export class QueryEngine {
     const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
     // Stream model response
-    for await (const chunk of this.registry.chat({
-      model: this.registry.getActiveModel(),
-      messages,
-      systemPrompt,
-      tools: toolDefs.length > 0 ? toolDefs : undefined,
-    })) {
-      yield chunk
-
-      if (chunk.type === 'error') {
-        this.context.addMessage({ role: 'assistant', content: `Error: ${chunk.error}` })
-        return
-      }
+    try {
+      for await (const chunk of this.registry.chat({
+        model: this.registry.getActiveModel(),
+        messages,
+        systemPrompt,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        signal,
+      })) {
+        yield chunk
 
-      if (chunk.type === 'text' && chunk.content) {
-        assistantContent += chunk.content
-      }
+        if (chunk.type === 'error') {
+          this.context.addMessage({ role: 'assistant', content: `Error: ${chunk.error}` })
+          return
+        }
 
-      if (chunk.type === 'tool_use' && chunk.toolUse) {
-        toolUses.push({
-          id: chunk.toolUse.id,
-          name: chunk.toolUse.name,
-          input: chunk.toolUse.input,
-        })
-      }
+        if (chunk.type === 'text' && chunk.content) {
+          assistantContent += chunk.content
+        }
 
-      if (chunk.type === 'stop') {
-        // Add assistant response to context
+        if (chunk.type === 'tool_use' && chunk.toolUse) {
+          toolUses.push({
+            id: chunk.toolUse.id,
+            name: chunk.toolUse.name,
+            input: chunk.toolUse.input,
+          })
+        }
+
+        if (chunk.type === 'stop') {
+          // Add assistant response to context
+          if (assistantContent) {
+            this.context.addMessage({ role: 'assistant', content: assistantContent })
+          }
+        }
+      }
+    } catch (err) {
+      if (isAbortError(err)) {
+        // User interrupted — keep partial content, stop gracefully
         if (assistantContent) {
           this.context.addMessage({ role: 'assistant', content: assistantContent })
         }
+        yield { type: 'stop' }
+        return
       }
+      yield { type: 'error', error: String(err) }
+      return
     }
 
     // Execute any tools that were requested
@@ -71,7 +139,7 @@ export class QueryEngine {
       yield {
         type: 'tool_result',
         tool_use_id: toolUse.id,
-        content: result.content,
+        content: result.success ? result.content : result.error || result.content,
       }
 
       // Add tool use + result to context
@@ -87,60 +155,80 @@ export class QueryEngine {
 
     // If tools were executed, recursively continue the conversation
     if (toolUses.length > 0) {
-      yield* this.continueWithTools()
+      yield* this.continueWithTools(signal)
     }
   }
 
-  private async *continueWithTools(): AsyncGenerator<StreamChunk> {
-    const systemPrompt = this.context.getSystemPrompt()
-    const messages = this.context.getMessages()
+  private async *continueWithTools(signal?: AbortSignal): AsyncGenerator<StreamChunk> {
+    const MAX_TURNS = 10
     const toolDefs = this.getToolDefinitions()
 
-    let assistantContent = ''
-    const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
+    for (let turn = 0; turn < MAX_TURNS; turn++) {
+      const systemPrompt = this.context.getSystemPrompt()
+      const messages = this.context.getMessages()
 
-    for await (const chunk of this.registry.chat({
-      model: this.registry.getActiveModel(),
-      messages,
-      systemPrompt,
-      tools: toolDefs.length > 0 ? toolDefs : undefined,
-    })) {
-      yield chunk
-
-      if (chunk.type === 'error') return
-      if (chunk.type === 'text' && chunk.content) assistantContent += chunk.content
-
-      if (chunk.type === 'tool_use' && chunk.toolUse) {
-        toolUses.push({
-          id: chunk.toolUse.id,
-          name: chunk.toolUse.name,
-          input: chunk.toolUse.input,
-        })
-      }
-    }
+      let assistantContent = ''
+      const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
 
-    if (assistantContent) {
-      this.context.addMessage({ role: 'assistant', content: assistantContent })
-    }
+      try {
+        for await (const chunk of this.registry.chat({
+          model: this.registry.getActiveModel(),
+          messages,
+          systemPrompt,
+          tools: toolDefs.length > 0 ? toolDefs : undefined,
+          signal,
+        })) {
+          yield chunk
 
-    // Execute tools (max 1 level of recursion to prevent infinite loops)
-    for (const toolUse of toolUses) {
-      const result = await this.executeTool(toolUse.name, toolUse.input)
-      yield {
-        type: 'tool_result',
-        tool_use_id: toolUse.id,
-        content: result.content,
+          if (chunk.type === 'error') return
+          if (chunk.type === 'text' && chunk.content) assistantContent += chunk.content
+
+          if (chunk.type === 'tool_use' && chunk.toolUse) {
+            toolUses.push({
+              id: chunk.toolUse.id,
+              name: chunk.toolUse.name,
+              input: chunk.toolUse.input,
+            })
+          }
+        }
+      } catch (err) {
+        if (isAbortError(err)) {
+          if (assistantContent) {
+            this.context.addMessage({ role: 'assistant', content: assistantContent })
+          }
+          yield { type: 'stop' }
+          return
+        }
+        return
       }
 
-      this.context.addMessage({
-        role: 'assistant',
-        content: [{ type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input }],
-      })
-      this.context.addMessage({
-        role: 'user',
-        content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result.content }],
-      })
+      if (assistantContent) {
+        this.context.addMessage({ role: 'assistant', content: assistantContent })
+      }
+
+      // No more tool calls — conversation complete
+      if (toolUses.length === 0) return
+
+      // Execute tools and feed results back to the model for the next turn
+      for (const toolUse of toolUses) {
+        const result = await this.executeTool(toolUse.name, toolUse.input)
+        yield {
+          type: 'tool_result',
+          tool_use_id: toolUse.id,
+          content: result.content,
+        }
+
+        this.context.addMessage({
+          role: 'assistant',
+          content: [{ type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input }],
+        })
+        this.context.addMessage({
+          role: 'user',
+          content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result.content }],
+        })
+      }
     }
+    // Max turns reached — safety limit, stop gracefully
   }
 
   private async executeTool(name: string, params: Record<string, unknown>): Promise<ToolResult> {
@@ -158,13 +246,37 @@ export class QueryEngine {
       }
     }
 
+    // Run PreToolUse hooks
+    let effectiveParams = params
+    if (this.hookEngine) {
+      const preResult = await this.hookEngine.executePreToolUse(name, params, 'session-1')
+      if (!preResult.allowed) {
+        return {
+          success: false,
+          content: '',
+          error: preResult.reason || `Tool "${name}" blocked by hook`,
+        }
+      }
+      if (preResult.modifiedInput) {
+        effectiveParams = { ...params, ...preResult.modifiedInput }
+      }
+    }
+
     try {
-      return await tool.execute(params, {
+      const result = await tool.execute(effectiveParams, {
         cwd: process.cwd(),
         sessionId: 'session-1',
         provider: this.registry.getActive().config.id,
         model: this.registry.getActiveModel(),
+        artifactServer: this.artifactServer,
       })
+
+      // Run PostToolUse hooks
+      if (this.hookEngine) {
+        await this.hookEngine.executePostToolUse(name, effectiveParams, result, 'session-1')
+      }
+
+      return result
     } catch (err) {
       return { success: false, content: '', error: String(err) }
     }
@@ -191,3 +303,14 @@ export class QueryEngine {
     this.registry.switchProvider(providerId, modelId)
   }
 }
+
+function isAbortError(err: unknown): boolean {
+  if (err instanceof Error && err.name === 'AbortError') return true
+  if (
+    typeof DOMException !== 'undefined' &&
+    err instanceof DOMException &&
+    err.name === 'AbortError'
+  )
+    return true
+  return false
+}

package/src/core/instructions.ts

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs'
+import { readFileSync, existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { parse as parseYaml } from 'yaml'
 import type { InstructionFile } from '../shared/index.ts'

package/src/core/permission.ts

@@ -1,7 +1,13 @@
-import type { ToolDefinition, ToolPermission, PermissionLevel } from '../shared/index.ts'
+import type {
+  ToolDefinition,
+  ToolPermission,
+  PermissionLevel,
+  PermissionRule,
+} from '../shared/index.ts'
 
 export class PermissionSystem {
   private rules = new Map<string, PermissionLevel>()
+  private patternRules: Array<{ pattern: RegExp; level: PermissionLevel }> = []
 
   constructor(private defaultLevel: ToolPermission = 'auto') {}
 
@@ -13,18 +19,43 @@ export class PermissionSystem {
     return this.defaultLevel
   }
 
-  setRule(toolName: string, level: PermissionLevel): void {
-    this.rules.set(toolName, level)
+  setRule(toolNameOrRule: string | PermissionRule, level?: PermissionLevel): void {
+    if (typeof toolNameOrRule === 'string') {
+      if (level) this.rules.set(toolNameOrRule, level)
+    } else {
+      const rule = toolNameOrRule
+      if (rule.pattern) {
+        this.patternRules.push({ pattern: new RegExp(rule.pattern), level: rule.level })
+      } else {
+        this.rules.set(rule.toolName, rule.level)
+      }
+    }
   }
 
   removeRule(toolName: string): void {
     this.rules.delete(toolName)
   }
 
+  /**
+   * Resolve permission level for a tool call.
+   *
+   * Fallback chain: exact rule → pattern rule → tool permission → system default
+   */
   check(tool: ToolDefinition, _input: Record<string, unknown>): PermissionLevel {
+    // 1. Exact-name rule wins
     const ruleLevel = this.rules.get(tool.name)
     if (ruleLevel) return ruleLevel
-    return tool.permission
+
+    // 2. Pattern-based rules (e.g. "file_*" → bypass)
+    for (const { pattern, level } of this.patternRules) {
+      if (pattern.test(tool.name)) return level
+    }
+
+    // 3. Tool's own permission level
+    if (tool.permission) return tool.permission
+
+    // 4. System default
+    return this.defaultLevel
   }
 
   needsApproval(tool: ToolDefinition, input: Record<string, unknown>): boolean {

package/src/core/session-store.ts

@@ -4,6 +4,7 @@ import {
   readFileSync,
   writeFileSync,
   unlinkSync,
+  renameSync,
   existsSync,
 } from 'node:fs'
 import { join } from 'node:path'
@@ -60,7 +61,10 @@ export class SessionStore {
       messages,
     }
 
-    writeFileSync(path, JSON.stringify(session) + '\n', 'utf-8')
+    // Atomic write: write to temp file, then rename (same-fs rename is atomic)
+    const tmp = path + '.tmp'
+    writeFileSync(tmp, JSON.stringify(session) + '\n', 'utf-8')
+    renameSync(tmp, path)
   }
 
   /**

package/src/index.tsx

@@ -1,3 +1,4 @@
+import { join } from 'node:path'
 import { render } from 'ink'
 import { App } from './ui/app'
 import { loadConfig } from './config/loader'
@@ -8,6 +9,10 @@ import { QueryEngine } from './core/engine'
 import { SessionStore } from './core/session-store'
 import { SkillsLoader } from './skills/loader'
 import { createToolRegistry } from './tools'
+import { McpClient } from './mcp/client'
+import { HookEngine } from './core/hooks'
+import { ArtifactServer } from './artifacts/server'
+import { ARTIFACTS_DIR, ARTIFACT_PORT, MIPHAM_DIR } from './shared/constants'
 
 interface RunOptions {
   model?: string
@@ -24,6 +29,17 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Load configuration
   const config = loadConfig()
 
+  // Connect MCP servers (fire-and-forget — do not block startup)
+  const mcpServers = config.skills?.mcpServers ?? []
+  if (mcpServers.length > 0) {
+    const mcp = McpClient.getInstance()
+    for (const server of mcpServers) {
+      mcp.connect(server).catch((err) => {
+        process.stderr.write(`[mcp] Failed to connect "${server.name}": ${String(err)}\n`)
+      })
+    }
+  }
+
   // Bootstrap providers
   const defaultProvider = options.provider || config.defaultProvider
   const defaultModel = options.model || config.defaultModel
@@ -60,14 +76,31 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Create tool registry with all 16 tools
   const tools = createToolRegistry()
 
+  // Initialize hook engine — register skill-defined hooks
+  const hookEngine = new HookEngine()
+  for (const skill of skillsLoader.list()) {
+    if (skill.hooks) {
+      for (const hook of skill.hooks) {
+        hookEngine.register(hook)
+      }
+    }
+  }
+
+  // Start artifact server (lazy — first artifact creation triggers listening)
+  const artifactsDir = join(process.cwd(), MIPHAM_DIR, ARTIFACTS_DIR)
+  const artifactServer = new ArtifactServer(artifactsDir, ARTIFACT_PORT)
+
   // Create query engine
   const engine = new QueryEngine(registry, context, tools)
+  engine.setHookEngine(hookEngine)
+  engine.setArtifactServer(artifactServer)
+  engine.setupContextSummarizer()
 
   // Auto-save session on exit
-  let autoSaveName: string | undefined
   const saveAndExit = () => {
+    artifactServer.stop()
     if (context.getMessageCount() > 0) {
-      autoSaveName = SessionStore.autoSave(context.getMessages(), {
+      SessionStore.autoSave(context.getMessages(), {
         provider: defaultProvider,
         model: defaultModel,
       })

package/src/mcp/transport.ts

@@ -1,11 +1,51 @@
 import { spawn, type ChildProcess } from 'node:child_process'
 import type { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './types'
 
-type ResponseHandler = (response: JsonRpcResponse) => void
 type NotificationHandler = (notification: JsonRpcNotification) => void
 
 const REQUEST_TIMEOUT_MS = 30_000
 
+// ── Environment variable security: block sensitive vars from MCP subprocess ──
+//
+// By default, MCP servers receive a sanitised copy of the parent environment.
+// Sensitive values (API keys, tokens, secrets, cloud credentials) are stripped
+// to prevent data exfiltration by third-party MCP plugins.
+//
+// The `env` parameter on `start()` allows explicit overrides — use it to
+// intentionally pass specific values to a trusted MCP server.
+const SENSITIVE_ENV_PATTERNS = [
+  /_API_KEY$/i, // ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
+  /_SECRET$/i, // STRIPE_SECRET, etc.
+  /_TOKEN$/i, // GITHUB_TOKEN, NPM_TOKEN, etc.
+  /_PASSWORD$/i, // DB_PASSWORD, etc.
+  /_CREDENTIALS?$/i, // GOOGLE_APPLICATION_CREDENTIALS, etc.
+  /^AWS_/, // AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, etc.
+  /^GCLOUD_/, // GCP credentials
+  /^AZURE_/, // Azure credentials
+  /^DOCKER_/, // DOCKER_TOKEN, DOCKER_PASSWORD
+]
+
+/**
+ * Build a sanitised environment for MCP subprocesses.
+ * Strips sensitive vars; allows explicit overrides via `extra`.
+ */
+function buildProcEnv(extra?: Record<string, string>): Record<string, string> {
+  const sanitized: Record<string, string> = {}
+
+  for (const [key, value] of Object.entries(process.env as Record<string, string>)) {
+    if (value === undefined) continue
+    if (SENSITIVE_ENV_PATTERNS.some((p) => p.test(key))) continue
+    sanitized[key] = value
+  }
+
+  // Explicit overrides take precedence (for intentionally shared secrets)
+  if (extra) {
+    Object.assign(sanitized, extra)
+  }
+
+  return sanitized
+}
+
 /**
  * MCP stdio transport — spawns a subprocess and communicates via
  * newline-delimited JSON-RPC 2.0 messages on stdin/stdout.
@@ -30,10 +70,7 @@ export class StdioTransport {
   async start(command: string, args: string[], env?: Record<string, string>): Promise<void> {
     this.closed = false
 
-    const procEnv: Record<string, string> = {
-      ...(process.env as Record<string, string>),
-      ...env,
-    }
+    const procEnv = buildProcEnv(env)
 
     return new Promise((resolve, reject) => {
       const child = spawn(command, args, {

package/src/providers/anthropic.ts

@@ -6,6 +6,7 @@ import type {
   ContentBlock,
 } from '../shared/index.ts'
 import type { ProviderInstance, ChatRequest } from './registry'
+import { fetchWithRetry } from './fetch-utils'
 
 interface AnthropicContentBlock {
   type: string
@@ -72,7 +73,7 @@ export class AnthropicProvider implements ProviderInstance {
       }))
     }
 
-    const response = await fetch(`${this.baseUrl}/messages`, {
+    const response = await fetchWithRetry(`${this.baseUrl}/messages`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',

package/src/providers/fetch-utils.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared fetch utilities — retry, timeout, backoff.
+ *
+ * Both AnthropicProvider and OpenAICompatProvider use these for
+ * resilient API communication.
+ */
+
+export interface FetchWithRetryOptions {
+  /** Request timeout in ms (applied via AbortController). */
+  timeout?: number
+  /** Maximum retry attempts (default 0 = no retry). */
+  maxRetries?: number
+  /** Base delay for exponential backoff in ms (default 1000). */
+  baseDelay?: number
+}
+
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504])
+
+function isRetryableError(err: unknown): boolean {
+  if (err instanceof DOMException && err.name === 'AbortError') return false
+  return true
+}
+
+/**
+ * Fetch with optional timeout and retry with exponential backoff.
+ *
+ * Retries on: network errors, 5xx, 429.
+ * Does NOT retry on: timeout (AbortError), 4xx (except 429).
+ */
+export async function fetchWithRetry(
+  url: string,
+  init: RequestInit,
+  options: FetchWithRetryOptions = {},
+): Promise<Response> {
+  const { timeout = 60_000, maxRetries = 2, baseDelay = 1000 } = options
+
+  let lastErr: unknown
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeout)
+    const signal = init.signal ? anySignal([init.signal, controller.signal]) : controller.signal
+
+    try {
+      const response = await fetch(url, { ...init, signal })
+
+      // 429 / 5xx → retry
+      if (RETRYABLE_STATUSES.has(response.status) && attempt < maxRetries) {
+        const retryAfter = response.headers.get('Retry-After')
+        const delay = retryAfter
+          ? parseInt(retryAfter, 10) * 1000
+          : baseDelay * Math.pow(2, attempt)
+        await sleep(delay)
+        continue
+      }
+
+      return response
+    } catch (err) {
+      lastErr = err
+      if (!isRetryableError(err) || attempt >= maxRetries) throw err
+      await sleep(baseDelay * Math.pow(2, attempt))
+    } finally {
+      clearTimeout(timer)
+      // Clean up combined signal if we created one
+      if (init.signal) {
+        try {
+          controller.abort()
+        } catch {
+          /* best effort */
+        }
+      }
+    }
+  }
+
+  throw lastErr
+}
+
+/** Simple promise-based sleep. */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Combine multiple AbortSignals into one — any signal aborting
+ * triggers the combined signal.
+ */
+function anySignal(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController()
+  const onAbort = () => {
+    controller.abort()
+    for (const s of signals) s.removeEventListener('abort', onAbort)
+  }
+  for (const s of signals) {
+    if (s.aborted) {
+      controller.abort()
+      return controller.signal
+    }
+    s.addEventListener('abort', onAbort)
+  }
+  return controller.signal
+}