@miphamai/cli 0.37.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/app.tsx

@@ -11,6 +11,8 @@ import { setPreference } from '../config/preferences'
 import { saveProviderApiKey } from '../config/loader'
 import { AgentRegistry } from '../agent/agent-registry'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
+import { getMessageRouter, parseMention, resolveRecipientSession } from '../agent/message-router'
+import { discoverSessions } from '../agent/cross-session/discovery'
 import { ChatPanel } from './chat'
 import { InputBar } from './input'
 import { ModelPicker } from './picker'
@@ -325,6 +327,40 @@ export function App({
     async (input: string) => {
       if (!input.trim()) return
 
+      // ── @mention: direct cross-session message — only when the name resolves
+      // to a live session; otherwise fall through to normal AI processing so a
+      // leading `@word` (e.g. "@bob please review") isn't hijacked as a send. ──
+      const mention = parseMention(input)
+      if (mention && resolveRecipientSession(discoverSessions(), mention.name).session) {
+        if (!mention.message) {
+          setMessages((prev) => [
+            ...prev,
+            { role: 'user', content: input },
+            { role: 'system', content: 'Usage: @session-name <message>' },
+          ])
+          return
+        }
+        const mentionSummary =
+          mention.message.length > 50 ? mention.message.slice(0, 47) + '...' : mention.message
+        const result = await getMessageRouter().route(
+          sessionId || 'main',
+          mention.name,
+          mentionSummary,
+          mention.message,
+        )
+        setMessages((prev) => [
+          ...prev,
+          { role: 'user', content: input },
+          {
+            role: 'system',
+            content: result.success
+              ? `── Message sent to ${mention.name} ──${result.messageId ? `\nID: ${result.messageId}` : ''}`
+              : `❌ Failed to send to ${mention.name}: ${result.error}`,
+          },
+        ])
+        return
+      }
+
       // ── Slash command dispatch ──
       if (looksLikeSlashCommand(input)) {
         const { command, args } = parseSlashCommand(input)

package/src/ui/commands.ts

@@ -12,6 +12,7 @@ import type { Message } from '../shared/types.js'
 import { McpClient } from '../mcp/client'
 import { NPM_UPDATE_COMMAND, PACKAGE_VERSION } from '../shared/index.ts'
 import { getPreference } from '../config/preferences'
+import { loadCrossSessionConfig } from '../config/loader'
 import { stripIndent } from './strip-indent.js'
 import { createT } from '../i18n-core/t'
 import type { TranslationMap } from '../i18n-core/types'
@@ -43,6 +44,7 @@ import { keysCmd } from '../commands/keys'
 import { workflowViewCmd, workflowWatchCmd } from '../commands/workflow-view.js'
 import { execSync } from 'node:child_process'
 import { OLLAMA_PRESET_MODELS } from '../shared/constants'
+import { renameActiveSession } from '../agent/cross-session/discovery'
 
 export interface CommandContext {
   engine: QueryEngine
@@ -517,12 +519,16 @@ const switchCmd: CommandHandler = (ctx, args) => {
 const configCmd: CommandHandler = (ctx) => {
   const t = resolveT(ctx)
   const c = ctx.config
+  const xs = loadCrossSessionConfig(process.cwd())
   const lines = [
     `version:          ${c.version}`,
     `defaultProvider:  ${c.defaultProvider}`,
     `defaultModel:     ${c.defaultModel}`,
     `permission:       ${c.permission}`,
     `providers:        ${c.providers.length} configured`,
+    '',
+    `crossSessionInbound: ${xs.crossSessionInbound}`,
+    `dialogExpiry:        ${xs.dialogExpiry}s`,
   ]
   return {
     content: `${t('commands.config.title')}\n${lines.join('\n')}\n\n${t('commands.config.edit')}`,
@@ -1588,7 +1594,10 @@ const renameCmd: CommandHandler = (ctx, args) => {
     return { content: t('commands.rename.usage') }
   }
   ctx.setSessionTitle(name.trim())
-  return { content: t('commands.rename.confirmed', { name: name.trim() }) }
+  // Persist to the cross-session registry so `@name` can address this session.
+  // Returns the (possibly uniquified) final name — surface that to the user.
+  const finalName = renameActiveSession(ctx.sessionId, name.trim())
+  return { content: t('commands.rename.confirmed', { name: finalName ?? name.trim() }) }
 }
 
 const goalCmd: CommandHandler = (ctx, args) => {
@@ -2831,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 */
@@ -4040,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/ui/input.tsx

@@ -5,6 +5,7 @@ import { VimMotionEngine, type VimMode } from './vim-motions.js'
 import { getCommandList } from './commands.js'
 import { CommandPicker } from './command-picker.js'
 import { useI18n } from '../i18n-context'
+import { discoverSessions } from '../agent/cross-session/discovery'
 
 interface InputBarProps {
   onSubmit: (input: string) => void
@@ -107,6 +108,15 @@ export function InputBar({
     return allCommands.filter((c) => c.name.toLowerCase().includes(filter)).slice(0, 8)
   }, [value, allCommands])
 
+  // ── @mention hints (cross-session recipients) ──
+  const mentionHints = useMemo(() => {
+    if (!value.startsWith('@')) return []
+    const filter = value.slice(1).toLowerCase()
+    const names = discoverSessions().map((s) => s.name)
+    if (!filter) return names.slice(0, 12)
+    return names.filter((n) => n.toLowerCase().includes(filter)).slice(0, 8)
+  }, [value])
+
   // Rotate gerunds while loading — use tRef to avoid re-running when i18n context re-renders
   useEffect(() => {
     if (!isLoading) return
@@ -448,6 +458,17 @@ export function InputBar({
           </Text>
         </Box>
       )}
+      {/* @mention hints — active sessions (cross-session messaging) */}
+      {mentionHints.length > 0 && vimMode === 'insert' && !pickerActive && (
+        <Box marginTop={1} flexDirection="column" gap={1}>
+          <Text dimColor>{t('ui.mention_hints.label')} </Text>
+          {mentionHints.map((name) => (
+            <Text key={name} color="green">
+              {name}
+            </Text>
+          ))}
+        </Box>
+      )}
     </Box>
   )
 }

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'