@miphamai/cli 0.37.0 → 0.38.0

package/package.json

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

package/src/agent/cross-session/discovery.ts

@@ -5,6 +5,7 @@ import {
   existsSync,
   mkdirSync,
   unlinkSync,
+  statSync,
 } from 'node:fs'
 import { join } from 'node:path'
 import { homedir, hostname } from 'node:os'
@@ -13,6 +14,9 @@ import type { SessionInfo } from '../../shared/types'
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const ACTIVE_SESSIONS_DIR = join(MIPHAM_HOME, '.active-sessions')
 
+/** A session whose heartbeat file hasn't been touched in this long is dead. */
+const STALE_SESSION_TTL_MS = 10 * 60 * 1000 // 10 min — heartbeat is 30s
+
 /**
  * Register the current session as active.
  * Writes a SessionInfo JSON file + updates mtime for heartbeat.
@@ -56,11 +60,19 @@ export function discoverSessions(): SessionInfo[] {
 
   try {
     const files = readdirSync(ACTIVE_SESSIONS_DIR).filter((f) => f.endsWith('.json'))
+    const now = Date.now()
 
     const sessions: SessionInfo[] = []
     for (const file of files) {
+      const filePath = join(ACTIVE_SESSIONS_DIR, file)
       try {
-        const raw = readFileSync(join(ACTIVE_SESSIONS_DIR, file), 'utf-8')
+        // Prune stale session files (crashed without unregistering). A live
+        // session's 30s heartbeat keeps mtime fresh; 10 min of silence = dead.
+        if (now - statSync(filePath).mtimeMs > STALE_SESSION_TTL_MS) {
+          unlinkSync(filePath)
+          continue
+        }
+        const raw = readFileSync(filePath, 'utf-8')
         const info = JSON.parse(raw) as SessionInfo
         sessions.push(info)
       } catch {
@@ -97,3 +109,35 @@ export function createSessionInfo(
     model,
   }
 }
+
+/**
+ * Return a unique session name among active sessions. If `preferred` is taken
+ * by another session (excluding `selfId`), append `-2`, `-3`, … until free.
+ * Pure with respect to `existing` — no filesystem access, so it's unit-testable.
+ */
+export function ensureUniqueSessionName(
+  preferred: string,
+  existing: SessionInfo[],
+  selfId?: string,
+): string {
+  const taken = new Set(existing.filter((s) => s.id !== selfId).map((s) => s.name))
+  if (!taken.has(preferred)) return preferred
+  let i = 2
+  while (taken.has(`${preferred}-${i}`)) i++
+  return `${preferred}-${i}`
+}
+
+/**
+ * Rename an active session in the registry. Enforces uniqueness against other
+ * live sessions (excluding self). Returns null if the session isn't registered.
+ */
+export function renameActiveSession(sessionId: string, newName: string): string | null {
+  const filePath = join(ACTIVE_SESSIONS_DIR, `${sessionId}.json`)
+  if (!existsSync(filePath)) return null
+  const raw = readFileSync(filePath, 'utf-8')
+  const info = JSON.parse(raw) as SessionInfo
+  const others = discoverSessions().filter((s) => s.id !== sessionId)
+  info.name = ensureUniqueSessionName(newName, others)
+  writeFileSync(filePath, JSON.stringify(info, null, 2), 'utf-8')
+  return info.name
+}

package/src/agent/cross-session/file-inbox.ts

@@ -6,6 +6,7 @@ import {
   unlinkSync,
   existsSync,
   renameSync,
+  lstatSync,
 } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
@@ -16,6 +17,15 @@ import type { SessionInfo } from '../../shared/types'
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const INBOX_DIR = join(MIPHAM_HOME, 'inbox')
 
+/** True if a path exists and is a symbolic link (symlink-attack guard). */
+function isSymlink(path: string): boolean {
+  try {
+    return lstatSync(path).isSymbolicLink()
+  } catch {
+    return false
+  }
+}
+
 /**
  * Filesystem-based cross-session transport.
  *
@@ -43,6 +53,9 @@ export class FileInboxTransport implements CrossSessionTransport {
       const inboxDir = join(INBOX_DIR, toSessionId)
       this.ensureDir(inboxDir)
 
+      // Symlink guard: refuse to write through a symlinked inbox directory.
+      if (isSymlink(INBOX_DIR) || isSymlink(inboxDir)) return false
+
       const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
       const filename = `${timestamp}-${msg.id}.json`
       const filePath = join(inboxDir, filename)
@@ -71,6 +84,8 @@ export class FileInboxTransport implements CrossSessionTransport {
     this.ensureInboxRoot()
     const inboxDir = join(INBOX_DIR, sessionId)
     if (!existsSync(inboxDir)) return []
+    // Symlink guard: refuse to read through a symlinked inbox directory.
+    if (isSymlink(INBOX_DIR) || isSymlink(inboxDir)) return []
 
     try {
       const files = readdirSync(inboxDir)

package/src/agent/message-router.ts

@@ -40,6 +40,24 @@ export function resolveRecipientSession(sessions: SessionInfo[], to: string): Se
   }
 }
 
+export interface MentionParse {
+  name: string
+  message: string
+}
+
+/**
+ * Parse a user-input `@name message` mention. Returns null when the input does
+ * not start with an @mention. The message may be empty — callers decide whether
+ * an empty body is valid. Used by the input bar to route a direct cross-session
+ * message without going through the AI.
+ */
+export function parseMention(input: string): MentionParse | null {
+  const trimmed = input.trim()
+  const m = /^@(\S+)(?:\s+([\s\S]+))?$/.exec(trimmed)
+  if (!m) return null
+  return { name: m[1]!, message: (m[2] ?? '').trim() }
+}
+
 /**
  * MessageRouter decides how to deliver a message based on the recipient.
  *
@@ -72,8 +90,10 @@ export class MessageRouter {
     }
     const targetSession = resolution.session!
 
-    // Get sender info
-    const senderSession = createSessionInfo(from, from)
+    // Get sender info — resolve the human-readable name when the sender is a
+    // registered session, else fall back to the raw id (e.g. non-session senders).
+    const senderName = discoverSessions().find((s) => s.id === from)?.name ?? from
+    const senderSession = createSessionInfo(from, senderName)
 
     try {
       const transport = getFileInboxTransport()

package/src/core/engine.ts

@@ -35,7 +35,7 @@ import { SelfCritique } from './self-critique.js'
 import { UsageTracker } from './usage-tracker'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
-import { getMessageBus } from '../agent/message-bus'
+import { getMessageBus, type AgentMessage } from '../agent/message-bus'
 import { createT } from '../i18n-core/t'
 import enUS from '../i18n-core/locales/en-US.json'
 import zhCN from '../i18n-core/locales/zh-CN.json'
@@ -47,6 +47,20 @@ const bundles: Record<string, TranslationMap> = {
 }
 const t = createT(bundles['en-US'] || (enUS as TranslationMap), enUS as TranslationMap)
 
+/**
+ * Drop inbound messages whose timestamp is older than the dialog-expiry TTL.
+ * A stale message's approval dialog is no longer relevant, so it's discarded
+ * before forwarding. Pure — unit-testable without touching the inbox.
+ */
+export function filterExpiredMessages(
+  messages: AgentMessage[],
+  dialogExpirySeconds: number,
+  now = Date.now(),
+): AgentMessage[] {
+  const maxAgeMs = dialogExpirySeconds * 1000
+  return messages.filter((m) => now - new Date(m.timestamp).getTime() <= maxAgeMs)
+}
+
 export class QueryEngine {
   private hookEngine?: HookEngine
   private artifactServer?: ArtifactServer
@@ -131,8 +145,11 @@ export class QueryEngine {
       const transport = getFileInboxTransport()
       const messages = await transport.poll(this.sessionId)
       if (messages.length > 0) {
+        // dialogExpiry: discard messages older than the approval-dialog TTL
+        const fresh = filterExpiredMessages(messages, this.crossSessionConfig.dialogExpiry)
+        if (fresh.length === 0) return
         const bus = getMessageBus()
-        for (const msg of messages) {
+        for (const msg of fresh) {
           // P2-1: Trigger Notification hook for cross-session messages
           if (this.hookEngine) {
             this.hookEngine

package/src/core/red-team.ts

@@ -19,6 +19,7 @@
 import type { ConstitutionLoader } from './constitution-loader.js'
 import type { PreFlightChecker } from './preflight-checker.js'
 import type { ErrorSignatureDB } from './error-signature-db.js'
+import { isBlocked } from '../tools/exec/bash'
 
 // ── Types ──
 
@@ -262,7 +263,21 @@ export class RedTeam {
       }
     }
 
-    // 3. Not caught — security gap
+    // 3. Check the real Bash tool's isBlocked — ground-truth defense, not just
+    // the constitution/preflight abstraction. Catches e.g. `git push --force`.
+    if (attack.toolName === 'Bash' && typeof attack.params.command === 'string') {
+      const blockedReason = isBlocked(attack.params.command)
+      if (blockedReason) {
+        return {
+          attack,
+          blocked: true,
+          caughtBy: 'bash-tool',
+          message: blockedReason,
+        }
+      }
+    }
+
+    // 4. Not caught — security gap
     return {
       attack,
       blocked: false,

package/src/core/workspace-trust.ts

@@ -25,6 +25,26 @@ function realPath(dir: string): string {
   }
 }
 
+/**
+ * True if a `.git` file or directory exists anywhere strictly between `dir` and
+ * its trusted ancestor `ancestor`. A `.git` marks the root of a separate
+ * repository — trust does not cross that boundary (nested-repo isolation).
+ */
+function hasGitBoundary(dir: string, ancestor: string): boolean {
+  let cur = dir
+  // Case-insensitive termination matches isTrusted's `toLowerCase()` ancestor
+  // check — otherwise a path referenced with different casing than when it was
+  // trusted would walk past the ancestor and miss the boundary.
+  const targetLower = ancestor.toLowerCase()
+  while (cur.toLowerCase() !== targetLower && cur.length > ancestor.length) {
+    if (existsSync(join(cur, '.git'))) return true
+    const parent = dirname(cur)
+    if (parent === cur) break
+    cur = parent
+  }
+  return false
+}
+
 /**
  * Manages the workspace trust store.
  *
@@ -82,8 +102,11 @@ export class WorkspaceTrust {
       const trustedLower = trusted.toLowerCase()
       // Exact match
       if (resolvedLower === trustedLower) return true
-      // Ancestor match: trusted dir is a parent of the target
-      if (resolvedLower.startsWith(trustedLower + '/')) return true
+      // Ancestor match: trusted dir is a parent of the target. Trust does not
+      // cross a nested git-repository boundary (vendored/submodule isolation).
+      if (resolvedLower.startsWith(trustedLower + '/') && !hasGitBoundary(resolved, trusted)) {
+        return true
+      }
     }
 
     return false

package/src/i18n-core/locales/en-US.json

@@ -682,6 +682,10 @@
       "count": "{shown} of {total}",
       "all": "all"
     },
+    "mention_hints": {
+      "label": "Sessions:",
+      "empty": "No active sessions"
+    },
     "picker": {
       "title": "Select Model",
       "nav_help": "←→ navigate · ↑↓ move · Enter select · Esc close",

package/src/i18n-core/locales/zh-CN.json

@@ -682,6 +682,10 @@
       "count": "{shown} / {total}",
       "all": "全部"
     },
+    "mention_hints": {
+      "label": "会话：",
+      "empty": "无活跃会话"
+    },
     "picker": {
       "title": "选择模型",
       "nav_help": "←→ 导航 · ↑↓ 移动 · Enter 选择 · Esc 关闭",

package/src/index.tsx

@@ -1,5 +1,5 @@
 import React from 'react'
-import { join } from 'node:path'
+import { join, basename } from 'node:path'
 import { homedir } from 'node:os'
 import { existsSync } from 'node:fs'
 import { render } from 'ink'
@@ -16,6 +16,8 @@ import {
   heartbeatSession,
   unregisterSession,
   createSessionInfo,
+  ensureUniqueSessionName,
+  discoverSessions,
 } from './agent/cross-session/discovery'
 import { bootstrapProviders } from './providers/bootstrap'
 import { InstructionsLoader } from './core/instructions'
@@ -515,9 +517,13 @@ export async function runApp(options: RunOptions): Promise<void> {
 
   // ── Cross-session messaging: register session, heartbeat, shutdown ──
   engine.setSessionId(sessionName)
+  // Human-readable, cross-session-addressable name. Defaults to the cwd basename
+  // so `@mipham-code` can address this session; uniqueness is enforced against
+  // other live sessions (suffix -2, -3, …). The id stays a stable `session-<ts>`.
+  const defaultName = basename(process.cwd()) || 'session'
   const sessionInfo = createSessionInfo(
     sessionName,
-    sessionName,
+    ensureUniqueSessionName(defaultName, discoverSessions()),
     process.cwd(),
     defaultProvider,
     defaultModel,

package/src/mcp/client.ts

@@ -22,6 +22,15 @@ const bundles: Record<string, TranslationMap> = {
 }
 const t = createT(bundles['en-US'] || (enUS as TranslationMap), enUS as TranslationMap)
 
+// Connect-handshake timeout: a hung MCP server should fail startup fast rather
+// than block on the per-request 60s timeout. Overridable via env for tests.
+const DEFAULT_CONNECT_TIMEOUT_MS = 15_000
+
+function connectTimeoutMs(): number {
+  const env = Number(process.env.MIPHAM_MCP_CONNECT_TIMEOUT_MS)
+  return Number.isFinite(env) && env > 0 ? env : DEFAULT_CONNECT_TIMEOUT_MS
+}
+
 interface ActiveConnection {
   config: McpServerConfig
   transport: Transport
@@ -167,33 +176,63 @@ export class McpClient {
     this.connections.set(config.name, connection)
 
     try {
-      // Start the transport (transport-specific), then perform the handshake.
-      if (transport instanceof HttpTransport) {
-        await transport.start(config.url ?? '', config.headers, config.env)
-      } else {
-        await transport.start(config.command ?? '', config.args ?? [], config.env)
-      }
-      const initResult: InitializeResult = await protocol.initialize()
+      await this.withConnectTimeout(config.name, async () => {
+        // Start the transport (transport-specific), then perform the handshake.
+        if (transport instanceof HttpTransport) {
+          await transport.start(config.url ?? '', config.headers, config.env)
+        } else {
+          await transport.start(config.command ?? '', config.args ?? [], config.env)
+        }
+        const initResult: InitializeResult = await protocol.initialize()
 
-      connection.status = 'connected'
-      connection.serverInfo = initResult.serverInfo
+        connection.status = 'connected'
+        connection.serverInfo = initResult.serverInfo
 
-      // Wire tools-changed notification
-      protocol.on('tools-changed', async () => {
-        await this.onToolsChanged(config.name)
-      })
+        // Wire tools-changed notification
+        protocol.on('tools-changed', async () => {
+          await this.onToolsChanged(config.name)
+        })
 
-      // Discover tools
-      if (initResult.capabilities.tools) {
-        connection.tools = await protocol.listTools()
-      }
+        // Discover tools
+        if (initResult.capabilities.tools) {
+          connection.tools = await protocol.listTools()
+        }
+      })
     } catch (err) {
       connection.status = 'error'
       connection.error = String(err)
+      try {
+        await transport.close()
+      } catch {
+        // Best-effort cleanup on a failed connect
+      }
       throw err
     }
   }
 
+  /** Race the connect handshake against a timeout so a hung server fails fast. */
+  private async withConnectTimeout<T>(name: string, fn: () => Promise<T>): Promise<T> {
+    const timeoutMs = connectTimeoutMs()
+    let timer: ReturnType<typeof setTimeout> | null = null
+    // Swallow a late rejection: if the timeout wins, transport.close() in the
+    // caller's catch makes fn()'s pending request reject after we've moved on.
+    const work = fn()
+    work.catch(() => {})
+    try {
+      return await Promise.race([
+        work,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error(`MCP connect timed out for "${name}" after ${timeoutMs}ms`)),
+            timeoutMs,
+          )
+        }),
+      ])
+    } finally {
+      if (timer) clearTimeout(timer)
+    }
+  }
+
   /**
    * Disconnect an MCP server and return the names of its registered tools
    * so the caller can unregister them from the central tool registry.

package/src/tools/exec/bash.ts

@@ -104,7 +104,7 @@ function normalizeEscapes(command: string): string {
   )
 }
 
-function isBlocked(command: string): string | null {
+export function isBlocked(command: string): string | null {
   // Normalize ANSI-C escape sequences for defense-in-depth
   const normalized = normalizeEscapes(command)
   // P0-1: Also sanitize for permission check (strips invisible chars, normalizes homoglyphs)

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) => {

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>
   )
 }