@miphamai/cli 0.38.0 → 0.39.0

package/src/tools/index.ts

@@ -1,15 +1,13 @@
-import type { ToolDefinition, ToolResult } from '../shared/index.ts'
-import { sanitizeParams } from '../shared/sanitize'
-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'
-import { readTool } from './file/read'
+import type { ToolDefinition } from '../shared/index.ts'
+import { Context } from '../vajra'
+import { withValidation } from './validation'
+import { toolService, collectTools } from './seam'
+import { readToolService } from './file/read'
 import { writeTool } from './file/write'
 import { editTool } from './file/edit'
 import { globTool } from './file/glob'
 import { grepTool } from './file/grep'
-import { bashTool } from './exec/bash'
+import { bashToolService } from './exec/bash'
 import { gitTool } from './exec/git'
 import { taskTool } from './exec/task'
 import { enterWorktreeTool } from './exec/enter-worktree'
@@ -33,141 +31,65 @@ import { listAgentsTool } from './agent/list-agents'
 import { computerUseTool } from './computer/computer-use'
 import { scheduleWakeupTool } from './scheduling/schedule-wakeup.js'
 import { cronCreateTool, cronDeleteTool, cronListTool } from './scheduling/cron.js'
+import { DISABLED_CREDENTIAL_MASKING_CONFIG } from '../config/defaults'
 
-const bundles: Record<string, TranslationMap> = {
-  'en-US': enUS as TranslationMap,
-  'zh-CN': zhCN as TranslationMap,
+function defaultToolContext(): Context {
+  const ctx = new Context()
+  // 掩码中立默认：无参调用（daemon/workflow）保持 Read/Bash 挂载，但不启用掩码，
+  // 对齐 pre-seam 行为（那些路径从不调用 setter）。显式开启掩码走 index.tsx 的加载配置。
+  ctx.provide('credentials', DISABLED_CREDENTIAL_MASKING_CONFIG)
+  return ctx
 }
-const t = createT(bundles['en-US'] || (enUS as TranslationMap), enUS as TranslationMap)
 
-/**
- * Validate tool parameters against the tool's JSON Schema definition.
- * Returns an array of error messages (empty = valid).
- */
-function validateParams(
-  schema: Record<string, unknown>,
-  params: Record<string, unknown>,
-): string[] {
-  const errors: string[] = []
-
-  // Check required fields
-  const required = schema.required as string[] | undefined
-  if (required) {
-    for (const field of required) {
-      if (params[field] === undefined || params[field] === null) {
-        errors.push(t('errors.missing_param', { param: field }))
-      }
-    }
-  }
-
-  // Check types for provided fields
-  const properties = schema.properties as
-    Record<string, { type: string; enum?: string[] }> | undefined
-  if (properties) {
-    for (const [key, def] of Object.entries(properties)) {
-      const value = params[key]
-      if (value === undefined || value === null) continue // already caught by required check
-
-      switch (def.type) {
-        case 'string':
-          if (typeof value !== 'string') errors.push(t('errors.type_string', { key }))
-          else if (def.enum && !def.enum.includes(value)) {
-            errors.push(t('errors.type_enum', { key, values: def.enum.join(', ') }))
-          }
-          break
-        case 'integer':
-        case 'number':
-          if (typeof value !== 'number') errors.push(t('errors.type_number', { key }))
-          break
-        case 'boolean':
-          if (typeof value !== 'boolean') errors.push(t('errors.type_boolean', { key }))
-          break
-        case 'object':
-          if (typeof value !== 'object' || Array.isArray(value)) {
-            errors.push(t('errors.type_object', { key }))
-          }
-          break
-        case 'array':
-          if (!Array.isArray(value)) errors.push(t('errors.type_array', { key }))
-          break
-      }
-    }
-  }
-
-  return errors
-}
-
-/**
- * Wrap a tool's execute with parameter validation.
- */
-function withValidation(tool: ToolDefinition): ToolDefinition {
-  const schema = tool.parameters as Record<string, unknown>
-  if (!schema || !schema.properties) return tool // no schema to validate against
-
-  return {
-    ...tool,
-    async execute(params, ctx): Promise<ToolResult> {
-      // Sanitize dangerous Unicode from all inputs
-      const cleanParams = sanitizeParams(params)
-      const errors = validateParams(schema, cleanParams)
-      if (errors.length > 0) {
-        return {
-          success: false,
-          content: '',
-          error: t('errors.invalid_params', { errors: errors.join('; ') }),
-        }
-      }
-      return tool.execute(cleanParams, ctx)
-    },
-  }
-}
-
-export function createToolRegistry(): Map<string, ToolDefinition> {
-  const tools: ToolDefinition[] = [
+export function createToolRegistry(
+  ctx: Context = defaultToolContext(),
+): Map<string, ToolDefinition> {
+  // 普通工具：包 withValidation 后作为 Service 挂载
+  const plainTools: ToolDefinition[] = [
     // File tools
-    withValidation(readTool),
-    withValidation(writeTool),
-    withValidation(editTool),
-    withValidation(globTool),
-    withValidation(grepTool),
+    writeTool,
+    editTool,
+    globTool,
+    grepTool,
     // Exec tools
-    withValidation(bashTool),
-    withValidation(gitTool),
-    withValidation(taskTool),
-    withValidation(enterWorktreeTool),
-    withValidation(exitWorktreeTool),
+    gitTool,
+    taskTool,
+    enterWorktreeTool,
+    exitWorktreeTool,
     // Agent tools
-    withValidation(agentTool),
-    withValidation(skillTool),
-    withValidation(planTool),
-    withValidation(enterPlanModeTool),
-    withValidation(exitPlanModeTool),
-    withValidation(memoryTool),
-    withValidation(workflowTool),
-    withValidation(reportFindingsTool),
-    withValidation(sendMessageTool),
-    withValidation(listAgentsTool),
+    agentTool,
+    skillTool,
+    planTool,
+    enterPlanModeTool,
+    exitPlanModeTool,
+    memoryTool,
+    workflowTool,
+    reportFindingsTool,
+    sendMessageTool,
+    listAgentsTool,
     // Network tools
-    withValidation(webFetchTool),
-    withValidation(webSearchTool),
+    webFetchTool,
+    webSearchTool,
     // System tools
-    withValidation(configTool),
-    withValidation(mcpTool),
-    withValidation(toolSearchTool),
+    configTool,
+    mcpTool,
+    toolSearchTool,
     // Artifact tools
-    withValidation(artifactTool),
+    artifactTool,
     // Computer Use tools
-    withValidation(computerUseTool),
+    computerUseTool,
     // Scheduling tools
-    withValidation(scheduleWakeupTool),
-    withValidation(cronCreateTool),
-    withValidation(cronDeleteTool),
-    withValidation(cronListTool),
+    scheduleWakeupTool,
+    cronCreateTool,
+    cronDeleteTool,
+    cronListTool,
   ]
-
-  const map = new Map<string, ToolDefinition>()
-  for (const tool of tools) {
-    map.set(tool.name, tool)
+  for (const tool of plainTools) {
+    ctx.mount(toolService(withValidation(tool)))
   }
-  return map
+  // 注入工具（credentials 依赖）：read + bash
+  ctx.mount(readToolService)
+  ctx.mount(bashToolService)
+
+  return collectTools(ctx)
 }

package/src/tools/network/web-fetch.ts

@@ -177,7 +177,7 @@ export const webFetchTool: ToolDefinition = {
     }
 
     // SSRF protection: validate URL before fetching
-    const validationError = validateUrl(url)
+    const validationError = await validateUrl(url)
     if (validationError) {
       return { success: false, content: '', error: validationError }
     }
@@ -186,40 +186,55 @@ export const webFetchTool: ToolDefinition = {
       const controller = new AbortController()
       const timer = setTimeout(() => controller.abort(), 30_000) // 30s timeout
 
-      const response = await fetch(url, {
-        headers: {
-          'User-Agent': 'Mipham-Code/0.24.0',
-          Accept: 'text/html,application/xhtml+xml,*/*',
-        },
-        redirect: 'follow',
-        signal: controller.signal,
-      })
-
-      clearTimeout(timer)
-
-      // Cross-host redirect reporting
-      if (response.url) {
-        const finalHost = new URL(response.url).hostname
-        const originalHost = new URL(url).hostname
-        if (finalHost !== originalHost) {
-          return {
-            success: true,
-            content: `Redirected to: ${response.url}\n\nFetch from this URL directly to retrieve content.`,
-            metadata: { redirected: true, originalUrl: url, finalUrl: response.url },
-          }
-        }
-
-        // SSRF defense: re-validate the resolved URL after redirects
-        const redirectError = validateUrl(response.url)
+      // Manual redirect handling: follow same-host redirects one hop at a time,
+      // validating the target BEFORE each request (closes the SSRF-via-redirect gap).
+      let currentUrl = url
+      const originalHost = new URL(url).hostname
+      let response!: Response
+
+      for (let hop = 0; hop <= 5; hop++) {
+        response = await fetch(currentUrl, {
+          headers: {
+            'User-Agent': 'Mipham-Code/0.24.0',
+            Accept: 'text/html,application/xhtml+xml,*/*',
+          },
+          redirect: 'manual',
+          signal: controller.signal,
+        })
+
+        // Not a redirect (or no Location) → proceed with this response
+        if (response.status < 300 || response.status >= 400) break
+        const location = response.headers.get('location')
+        if (!location || hop === 5) break
+
+        const nextUrl = new URL(location, currentUrl).toString()
+
+        // SSRF defense: validate the redirect target BEFORE following
+        const redirectError = await validateUrl(nextUrl)
         if (redirectError) {
+          clearTimeout(timer)
           return {
             success: false,
             content: '',
             error: `Redirect blocked: ${redirectError}`,
           }
         }
+
+        // Cross-host redirects are returned to the caller (tool contract)
+        if (new URL(nextUrl).hostname !== originalHost) {
+          clearTimeout(timer)
+          return {
+            success: true,
+            content: `Redirected to: ${nextUrl}\n\nFetch from this URL directly to retrieve content.`,
+            metadata: { redirected: true, originalUrl: url, finalUrl: nextUrl },
+          }
+        }
+
+        currentUrl = nextUrl
       }
 
+      clearTimeout(timer)
+
       // Determine content type; only convert HTML to markdown
       const contentType = response.headers.get('content-type') || ''
       const isHtml = contentType.includes('text/html') || contentType.includes('application/xhtml')

package/src/tools/seam.ts

@@ -0,0 +1,25 @@
+import type { Context, Service } from '../vajra'
+import type { ToolDefinition } from '../shared'
+
+/** 工具服务键前缀。一个已挂载工具以 `tool:<name>` 注册于 Context。 */
+export const toolKey = (name: string): string => `tool:${name}`
+
+/** 把普通 ToolDefinition 包装成 Vajra Service（无注入依赖）。 */
+export function toolService(tool: ToolDefinition): Service {
+  return {
+    apply(ctx) {
+      ctx.provide(toolKey(tool.name), tool)
+    },
+  }
+}
+
+/** 从 Context 已挂载的工具服务派生 name → definition 的 Map（engine 消费）。 */
+export function collectTools(ctx: Context): Map<string, ToolDefinition> {
+  const map = new Map<string, ToolDefinition>()
+  for (const key of ctx.keysRecursive()) {
+    if (!key.startsWith('tool:')) continue
+    const tool = ctx.get<ToolDefinition>(key)
+    if (tool) map.set(tool.name, tool)
+  }
+  return map
+}

package/src/tools/validation.ts

@@ -0,0 +1,91 @@
+import { sanitizeParams } from '../shared/sanitize'
+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'
+import type { ToolDefinition, ToolResult } from '../shared'
+
+const bundles: Record<string, TranslationMap> = {
+  'en-US': enUS as TranslationMap,
+  'zh-CN': zhCN as TranslationMap,
+}
+const t = createT(bundles['en-US'] || (enUS as TranslationMap), enUS as TranslationMap)
+
+/**
+ * Validate tool parameters against the tool's JSON Schema definition.
+ * Returns an array of error messages (empty = valid).
+ */
+export function validateParams(
+  schema: Record<string, unknown>,
+  params: Record<string, unknown>,
+): string[] {
+  const errors: string[] = []
+
+  const required = schema.required as string[] | undefined
+  if (required) {
+    for (const field of required) {
+      if (params[field] === undefined || params[field] === null) {
+        errors.push(t('errors.missing_param', { param: field }))
+      }
+    }
+  }
+
+  const properties = schema.properties as
+    Record<string, { type: string; enum?: string[] }> | undefined
+  if (properties) {
+    for (const [key, def] of Object.entries(properties)) {
+      const value = params[key]
+      if (value === undefined || value === null) continue
+
+      switch (def.type) {
+        case 'string':
+          if (typeof value !== 'string') errors.push(t('errors.type_string', { key }))
+          else if (def.enum && !def.enum.includes(value)) {
+            errors.push(t('errors.type_enum', { key, values: def.enum.join(', ') }))
+          }
+          break
+        case 'integer':
+        case 'number':
+          if (typeof value !== 'number') errors.push(t('errors.type_number', { key }))
+          break
+        case 'boolean':
+          if (typeof value !== 'boolean') errors.push(t('errors.type_boolean', { key }))
+          break
+        case 'object':
+          if (typeof value !== 'object' || Array.isArray(value)) {
+            errors.push(t('errors.type_object', { key }))
+          }
+          break
+        case 'array':
+          if (!Array.isArray(value)) errors.push(t('errors.type_array', { key }))
+          break
+      }
+    }
+  }
+
+  return errors
+}
+
+/**
+ * Wrap a tool's execute with parameter validation.
+ */
+export function withValidation(tool: ToolDefinition): ToolDefinition {
+  const schema = tool.parameters as Record<string, unknown>
+  if (!schema || !schema.properties) return tool
+
+  return {
+    ...tool,
+    async execute(params, ctx): Promise<ToolResult> {
+      const cleanParams = sanitizeParams(params)
+      const errors = validateParams(schema, cleanParams)
+      if (errors.length > 0) {
+        return {
+          success: false,
+          content: '',
+          error: t('errors.invalid_params', { errors: errors.join('; ') }),
+        }
+      }
+      return tool.execute(cleanParams, ctx)
+    },
+  }
+}

package/src/ui/commands.ts

@@ -2840,11 +2840,20 @@ const cdCmd: CommandHandler = async (ctx, args) => {
       const { SessionStore } = await import('../core/session-store')
       const saved = SessionStore.load(ctx.sessionId)
       if (saved) {
-        SessionStore.save(ctx.sessionId, saved.messages, {
-          provider: saved.metadata.provider,
-          model: saved.metadata.model,
-          cwd: resolved,
-        })
+        const log = ctx.engine.getContext().getLog()
+        if (log) {
+          SessionStore.saveLog(ctx.sessionId, log, {
+            provider: saved.metadata.provider,
+            model: saved.metadata.model,
+            cwd: resolved,
+          })
+        } else {
+          SessionStore.save(ctx.sessionId, saved.messages, {
+            provider: saved.metadata.provider,
+            model: saved.metadata.model,
+            cwd: resolved,
+          })
+        }
       }
     } catch {
       /* session persistence is best-effort */
@@ -4049,6 +4058,9 @@ const forkCmd: CommandHandler = async (ctx, args) => {
         ctx.engine.getRegistry(),
         ctx.engine.getTools(),
         ctx.engine.getPermission(),
+        undefined,
+        undefined,
+        ctx.engine.getLlm(),
       )
       const parentContext = ctx.engine.getContext()
       const result = await sa.execute(prompt, 'fork: ' + prompt.slice(0, 60), {

package/src/vajra/compose/assemble.ts

@@ -0,0 +1,19 @@
+import type { Profile, Bundle, BundleLine } from './bundle'
+
+export function assemble(profile: Profile, resolveBundle: (name: string) => Bundle): BundleLine[] {
+  // 浅拷贝每行，使 patch 不回写共享的 bundle 行对象（不同 profile 共享同一 bundle 时补丁隔离）
+  const lines = profile.bundles.flatMap((name) =>
+    resolveBundle(name).lines.map((l) => ({ ...l, config: { ...l.config } })),
+  )
+  if (profile.patch) {
+    for (const [id, partial] of Object.entries(profile.patch)) {
+      const target = lines.find((l) => l.id === id)
+      if (target) {
+        Object.assign(target, partial)
+      } else {
+        lines.push({ id, kind: partial.kind ?? 'tool', config: partial.config ?? {} })
+      }
+    }
+  }
+  return lines
+}

package/src/vajra/compose/bundle.ts

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs'
+import { parse as parseYaml } from 'yaml'
+
+export type BundleLine = {
+  id: string
+  kind: 'tool' | 'provider' | 'skill' | 'service'
+  config: Record<string, unknown>
+}
+export type Bundle = { name: string; lines: BundleLine[] }
+export type Profile = {
+  name: string
+  bundles: string[]
+  patch?: Record<string, Partial<BundleLine>>
+}
+
+export function loadBundle(path: string): Bundle {
+  const raw = readFileSync(path, 'utf-8')
+  const data = parseYaml(raw) as { name?: unknown; lines?: unknown }
+  if (data.lines !== undefined && !Array.isArray(data.lines)) {
+    throw new Error(`bundle "${path}": "lines" must be an array`)
+  }
+  return {
+    name: typeof data.name === 'string' ? data.name : path,
+    lines: (data.lines ?? []) as BundleLine[],
+  }
+}
+
+export function loadProfile(path: string): Profile {
+  const raw = readFileSync(path, 'utf-8')
+  const data = parseYaml(raw) as { name?: unknown; bundles?: unknown; patch?: unknown }
+  if (data.bundles !== undefined && !Array.isArray(data.bundles)) {
+    throw new Error(`profile "${path}": "bundles" must be an array`)
+  }
+  return {
+    name: typeof data.name === 'string' ? data.name : path,
+    bundles: (data.bundles ?? []) as string[],
+    patch: data.patch as Profile['patch'] | undefined,
+  }
+}

package/src/vajra/compose/dump.ts

@@ -0,0 +1,5 @@
+import type { BundleLine } from './bundle'
+
+export function dumpConfig(lines: BundleLine[]): string {
+  return lines.map((l) => `${l.id}\t${l.kind}\t${JSON.stringify(l.config)}`).join('\n')
+}

package/src/vajra/compose/index.ts

@@ -0,0 +1,4 @@
+export * from './bundle'
+export * from './assemble'
+export * from './dump'
+export * from './mount'

package/src/vajra/compose/mount.ts

@@ -0,0 +1,30 @@
+import type { Context, Mounted, Service } from '..'
+import type { Bundle, BundleLine, Profile } from './bundle'
+import { assemble } from './assemble'
+
+/** 服务解析器：bundle 行的「要挂的代码」——按行解析出要挂载的 Service；纯数据行（如 package-info）返回 undefined 跳过。 */
+export type ServiceResolver = (line: BundleLine) => Service | undefined
+
+/** 按行顺序把解析出的 Service 挂进 ctx（依赖未就位则挂起，语义同 ctx.mount）。 */
+export function mountLines(
+  ctx: Context,
+  lines: BundleLine[],
+  resolveService: ServiceResolver,
+): Mounted[] {
+  const mounted: Mounted[] = []
+  for (const line of lines) {
+    const service = resolveService(line)
+    if (service) mounted.push(ctx.mount(service))
+  }
+  return mounted
+}
+
+/** 从 profile 声明式挂载：assemble → mountLines 一整条链。 */
+export function mountProfile(
+  ctx: Context,
+  profile: Profile,
+  resolveBundle: (name: string) => Bundle,
+  resolveService: ServiceResolver,
+): Mounted[] {
+  return mountLines(ctx, assemble(profile, resolveBundle), resolveService)
+}