@miphamai/cli 0.81.5 → 0.81.7

package/src/telemetry/redact.ts

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto'
+import { homedir } from 'node:os'
+
+/**
+ * Redaction for crash reports.
+ *
+ * Nothing in this module is reusable from the existing scrubbers: the four
+ * families in the repo (`credential-masker/`, `security/gate.ts`,
+ * `shared/sanitize.ts`, `skills/sanitizer.ts`) all match *credential shapes* —
+ * token prefixes, JWTs, `sk-ant-…`. None of them removes a user name out of a
+ * path. The only home→`~` helper is `ui/chat.tsx` `displayCwd()`, which is
+ * unexported, has zero call sites, and only ever looks at `process.cwd()` — it
+ * cannot touch a path inside an error object or a stack frame.
+ *
+ * So the guarantee below has to be carried by tests, not by reuse.
+ */
+
+/** Frames kept by default. `Error.stackTraceLimit` is 10; we allow headroom. */
+export const MAX_STACK_FRAMES = 15
+
+/** Marker substituted for the working directory — hides the project name. */
+const CWD_MARKER = '<cwd>'
+
+/** Marker substituted for the home directory. */
+const HOME_MARKER = '~'
+
+/**
+ * Marker substituted for the first directory segment under home.
+ *
+ * Home replacement alone still discloses the user's own naming: a frame in
+ * `~/acme-secret-merger-2026/src/a.ts` would render as exactly that. The
+ * data dictionary promises no project names, so the segment right after `~` is
+ * collapsed too. Structure and the frame's own file name survive — which is
+ * what makes a frame useful — but the user's label for a directory does not.
+ */
+const DIR_MARKER = '<dir>'
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * Replace absolute home/cwd paths with their markers, anywhere in the string.
+ *
+ * Order matters and is not arbitrary: cwd is normally *inside* home, so
+ * replacing home first would leave `~/proj/src/a.ts` — which leaks the project
+ * directory name. Replacing cwd first yields `<cwd>/src/a.ts`, which does not.
+ * This ordering is asserted by a test.
+ *
+ * Paths that are neither under cwd nor under home are left alone. Those are
+ * system/package locations (e.g. `/usr/local/lib/node_modules/…`) that contain
+ * no user data, and keeping them is what makes a frame useful for debugging.
+ */
+export function redactText(input: string, cwd?: string): string {
+  let out = input
+
+  if (cwd && cwd.length > 1) {
+    out = out.replace(new RegExp(escapeRegExp(cwd), 'g'), CWD_MARKER)
+  }
+
+  let home = ''
+  try {
+    home = homedir()
+  } catch {
+    /* homedir() can throw when neither HOME nor the passwd entry resolves */
+  }
+  if (home && home.length > 1) {
+    out = out.replace(new RegExp(escapeRegExp(home), 'g'), HOME_MARKER)
+  }
+
+  // Collapse the first segment after `~` (both separators — Windows stacks use
+  // backslashes) so a user-chosen directory name is not disclosed. The matched
+  // separator is echoed back rather than normalised, so a Windows path does not
+  // come out with mixed separators.
+  out = out.replace(
+    /~([\\/])[^\\/\s:)]+/g,
+    (_match, sep: string) => `${HOME_MARKER}${sep}${DIR_MARKER}`,
+  )
+
+  return out
+}
+
+export interface RedactedStack {
+  /** Redacted frame lines, truncated to `maxFrames`. */
+  frames: string[]
+  /** Frame count *before* truncation — truncation loses data, this bounds the loss. */
+  frameCount: number
+}
+
+/**
+ * Extract and redact the frame lines of a V8 stack.
+ *
+ * The first line of a stack is `"TypeError: <message>"` — it is dropped
+ * outright, never redacted, because the message routinely embeds paths and user
+ * data. `crash.ts` sends only `hashMessage(error.message)` instead.
+ */
+export function redactStack(
+  stack: string,
+  opts: { cwd?: string; maxFrames?: number } = {},
+): RedactedStack {
+  const { cwd = process.cwd(), maxFrames = MAX_STACK_FRAMES } = opts
+
+  const frameLines = stack.split('\n').filter((line) => /^\s*at\s/.test(line))
+  const redacted = frameLines.map((line) => redactText(line.trim(), cwd))
+
+  return {
+    frames: redacted.slice(0, maxFrames),
+    frameCount: frameLines.length,
+  }
+}
+
+/**
+ * sha256 of the error message, first 16 hex chars.
+ *
+ * Only the digest is reportable. The plaintext message is not — same reason the
+ * stack's first line is dropped.
+ */
+export function hashMessage(message: string): string {
+  return createHash('sha256').update(message).digest('hex').slice(0, 16)
+}
+
+/** Runtime tag for the session payload, e.g. `bun@1.2` / `node@22`. */
+export function runtimeTag(): string {
+  const versions = process.versions as Record<string, string | undefined>
+  if (versions.bun) return `bun@${versions.bun}`
+  return `node@${(versions.node ?? '0').split('.')[0]}`
+}

package/src/telemetry/transport.ts

@@ -0,0 +1,81 @@
+import { fetchWithRetry } from '../providers/fetch-utils'
+import { ackQueue, readQueue, type QueuedEvent } from './queue'
+
+/**
+ * Upload queued events.
+ *
+ * Runs at *startup*, not at exit: `process.on('exit')` cannot await async work,
+ * so collecting and sending are decoupled — the session queue is written
+ * synchronously at exit and drained here on the next launch. Same shape as the
+ * existing startup update check (`shared/update.ts`), which is likewise
+ * fire-and-forget.
+ *
+ * Every failure is silent and leaves the event queued for the next attempt. A
+ * telemetry endpoint being unreachable must never be visible to the user.
+ */
+
+/** Per-request budget. Short: this runs alongside startup, not during it. */
+const REQUEST_TIMEOUT_MS = 10_000
+
+export interface FlushResult {
+  sent: number
+  failed: number
+}
+
+/**
+ * Drain the queue to `endpoint`.
+ *
+ * Returns without sending anything when the endpoint is empty — which is the
+ * shipped default, so an unconfigured install performs **zero** network calls.
+ */
+export async function flushQueue(
+  endpoint: string,
+  opts: { fetchImpl?: typeof fetch; events?: QueuedEvent[] } = {},
+): Promise<FlushResult> {
+  if (!endpoint) return { sent: 0, failed: 0 }
+
+  const events = opts.events ?? readQueue()
+  if (events.length === 0) return { sent: 0, failed: 0 }
+
+  const sent: string[] = []
+  let failed = 0
+
+  for (const event of events) {
+    try {
+      const response = await fetchWithRetry(
+        endpoint,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(event),
+        },
+        { timeout: REQUEST_TIMEOUT_MS, maxRetries: 2, baseDelay: 1000 },
+      )
+
+      // 4xx means we are sending something the endpoint will never accept —
+      // retrying forever would wedge the queue behind a permanently bad event.
+      // Drop it on the floor rather than block every later event.
+      if (response.ok || (response.status >= 400 && response.status < 500)) {
+        sent.push(event.id)
+      } else {
+        failed++
+      }
+    } catch {
+      failed++
+    }
+  }
+
+  ackQueue(sent)
+  return { sent: sent.length, failed }
+}
+
+/**
+ * Fire-and-forget startup flush. Never rejects, never blocks the caller, and
+ * never surfaces an error — the caller does not await it.
+ */
+export function flushQueueInBackground(endpoint: string): void {
+  if (!endpoint) return
+  void flushQueue(endpoint).catch(() => {
+    /* best-effort by design */
+  })
+}

package/src/tools/agent/workflow.ts

@@ -1,5 +1,6 @@
 import type { ToolDefinition } from '../../shared/index.ts'
 import { runWorkflow } from '../../workflow/runtime'
+import { workflowScriptDir } from '../../core/paths.ts'
 import type { QueryEngine } from '../../core/engine'
 
 export const workflowTool: ToolDefinition = {
@@ -108,10 +109,11 @@ export const workflowTool: ToolDefinition = {
       )
 
       // Persist last-run state for /workflow save
+      let persistWarning = ''
       try {
         const { existsSync, mkdirSync, writeFileSync } = await import('node:fs')
         const { join } = await import('node:path')
-        const workflowsDir = join(process.cwd(), '.claude', 'workflows')
+        const workflowsDir = workflowScriptDir(process.cwd())
         if (!existsSync(workflowsDir)) {
           mkdirSync(workflowsDir, { recursive: true })
         }
@@ -120,8 +122,13 @@ export const workflowTool: ToolDefinition = {
           JSON.stringify({ runId, script, timestamp: new Date().toISOString() }),
           'utf-8',
         )
-      } catch {
-        // best-effort — don't fail the workflow if state persistence fails
+      } catch (err) {
+        // Persistence stays best-effort — the workflow itself succeeded, so a
+        // disk error must not fail it. But it must not be *silent* either:
+        // swallowing this made the next `/workflow save` report "No recent
+        // workflow run found" while the script sat intact in
+        // ~/.mipham/workflows/<runId>/script.js.
+        persistWarning = `\n\n⚠️  Could not persist last-run state for /workflow save: ${String(err)}`
       }
 
       let content = `Workflow ${runId} completed.\n\n`
@@ -130,7 +137,7 @@ export const workflowTool: ToolDefinition = {
       }
       content += `Result:\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`
 
-      return { success: true, content }
+      return { success: true, content: content + persistWarning }
     } catch (err) {
       return {
         success: false,

package/src/tools/exec/bash.ts

@@ -2,6 +2,7 @@ import type { ToolDefinition, CredentialMaskingConfig } from '../../shared/index
 import { sanitizeCommand } from '../../shared/sanitize.ts'
 import { DANGEROUS_GIT_PATTERNS } from './git.ts'
 import { isUncOrDevicePath } from '../../security/path.ts'
+import { findWorktreeMarker } from '../../core/paths.ts'
 import type { Service } from '../../vajra'
 import { toolKey } from '../seam'
 import { withValidation } from '../validation'
@@ -334,9 +335,10 @@ export function createBashTool(credentialConfig?: CredentialMaskingConfig): Tool
       const timeout = Math.min((params.timeout as number) || 120_000, 600_000)
 
       // P0-4: Worktree isolation — block cd escape attempts
-      const WORKTREE_MARKER = '.claude/worktrees/'
-      if (ctx.cwd.includes(WORKTREE_MARKER)) {
-        const worktreeRoot = ctx.cwd.substring(0, ctx.cwd.indexOf(WORKTREE_MARKER))
+      // 标记取自 core/paths.ts：新目录与历史 .claude/worktrees/ 都认，
+      // 隔离度只增不减（只认新前缀会让旧工作树失去保护）。
+      const worktreeMarker = findWorktreeMarker(ctx.cwd)
+      if (worktreeMarker) {
         // Detect cd to absolute paths outside the worktree
         const cdEscapePattern = /\bcd\s+(?:"([^"]+)"|'([^']+)'|([^\s;|&]+))/
         const cdMatch = command.match(cdEscapePattern)
@@ -346,7 +348,7 @@ export function createBashTool(credentialConfig?: CredentialMaskingConfig): Tool
           const resolved = target.startsWith('/')
             ? target
             : `${ctx.cwd}/${target}`.replace(/\/\.\//g, '/')
-          if (!resolved.startsWith(ctx.cwd) && !resolved.startsWith(worktreeRoot + '/')) {
+          if (!resolved.startsWith(ctx.cwd) && !resolved.startsWith(worktreeMarker.root + '/')) {
             return {
               success: false,
               content: '',

package/src/tools/exec/enter-worktree.ts

@@ -1,10 +1,11 @@
 import type { ToolDefinition } from '../../shared/index.ts'
+import { worktreeRoot } from '../../core/paths.ts'
 
 export const enterWorktreeTool: ToolDefinition = {
   name: 'EnterWorktree',
   description:
     'Create an isolated git worktree for parallel development. ' +
-    'Creates a new worktree at .claude/worktrees/<name> on its own branch. ' +
+    'Creates a new worktree at .mipham/worktrees/<name> on its own branch. ' +
     'Use this when you need to work on a separate task without affecting the main workspace. ' +
     'Pair with ExitWorktree to clean up when done.',
   category: 'exec',
@@ -56,10 +57,10 @@ export const enterWorktreeTool: ToolDefinition = {
 
     const cwd = ctx.cwd
     const { resolve } = await import('node:path')
-    const worktreePath = resolve(`${cwd}/.claude/worktrees/${name}`)
-    const allowedPrefix = resolve(`${cwd}/.claude/worktrees/`)
+    const worktreePath = resolve(worktreeRoot(cwd), name)
+    const allowedPrefix = resolve(worktreeRoot(cwd))
 
-    // Defense-in-depth: verify resolved path is within .claude/worktrees/
+    // Defense-in-depth: verify resolved path stays within the worktree root
     if (
       !worktreePath.startsWith(allowedPrefix + '/') &&
       worktreePath !== allowedPrefix.slice(0, -1)
@@ -67,7 +68,7 @@ export const enterWorktreeTool: ToolDefinition = {
       return {
         success: false,
         content: '',
-        error: 'Worktree path must be within .claude/worktrees/.',
+        error: 'Worktree path must be within .mipham/worktrees/.',
       }
     }
 

package/src/tools/exec/exit-worktree.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '../../shared/index.ts'
+import { worktreeRoots } from '../../core/paths.ts'
 
 export const exitWorktreeTool: ToolDefinition = {
   name: 'ExitWorktree',
@@ -13,7 +14,8 @@ export const exitWorktreeTool: ToolDefinition = {
     properties: {
       path: {
         type: 'string',
-        description: 'Absolute path to the worktree to exit. Must be under .claude/worktrees/.',
+        description:
+          'Absolute path to the worktree to exit. Must be under .mipham/worktrees/ (or the legacy .claude/worktrees/).',
       },
       action: {
         type: 'string',
@@ -34,18 +36,21 @@ export const exitWorktreeTool: ToolDefinition = {
     const action = params.action as string
     const discardChanges = params.discard_changes === true
 
-    // Validate the path is under .claude/worktrees
+    // Validate the path is under a worktree root（新目录优先，兼容历史 .claude/）
     const cwd = ctx.cwd
     const { resolve } = await import('node:path')
     const resolvedPath = resolve(worktreePath)
-    const allowedPrefix = resolve(`${cwd}/.claude/worktrees/`)
+    const roots = worktreeRoots(cwd).map((root) => resolve(root))
+    const inWorktree = roots.some(
+      (root) => resolvedPath === root || resolvedPath.startsWith(root + '/'),
+    )
 
-    if (!resolvedPath.startsWith(allowedPrefix)) {
+    if (!inWorktree) {
       return {
         success: false,
         content: '',
         error:
-          `Path "${worktreePath}" is not under .claude/worktrees/. ` +
+          `Path "${worktreePath}" is not under .mipham/worktrees/ or .claude/worktrees/. ` +
           `Only worktrees created by EnterWorktree can be managed here.`,
       }
     }

package/src/tools/exec/git.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '../../shared/index.ts'
+import { findWorktreeMarker } from '../../core/paths.ts'
 
 // P0-4 (v2.1.222 alignment): Regex-based word-boundary patterns replace
 // fragile substring matching. Each pattern describes what it blocks.
@@ -52,14 +53,23 @@ export const DANGEROUS_GIT_PATTERNS: Array<{ pattern: RegExp; description: strin
  * when operating in a worktree context.
  */
 function isOutsideWorktree(command: string, cwd: string): string | null {
-  const WORKTREE_MARKER = '.claude/worktrees/'
-  if (!cwd.includes(WORKTREE_MARKER)) return null
-
-  // Extract the project root (everything before .claude/worktrees/)
-  const worktreeRoot = cwd.substring(0, cwd.indexOf(WORKTREE_MARKER))
-
-  // Detect git commands that reference the main checkout path
-  const mainCheckoutPaths = [/\b--work-tree=([^\s]+)/g, /\b--git-dir=([^\s]+)/g, /\b-C\s+([^\s]+)/g]
+  // 标记取自 core/paths.ts：新目录与历史 .claude/worktrees/ 都认，隔离度只增不减。
+  const marker = findWorktreeMarker(cwd)
+  if (!marker) return null
+
+  // Extract the project root (everything before the worktree marker)
+  const worktreeRoot = marker.root
+
+  // Detect git commands that reference the main checkout path.
+  // NOTE: no `\b` before the leading `-` — `\b` needs a word/non-word
+  // transition and `-` is itself a non-word char, so `\b--work-tree=` never
+  // matched anything and this whole check was silently dead. `-C` needs an
+  // explicit boundary because without one it would match inside a path.
+  const mainCheckoutPaths = [
+    /--work-tree=([^\s]+)/g,
+    /--git-dir=([^\s]+)/g,
+    /(?:^|\s)-C\s+([^\s]+)/g,
+  ]
 
   for (const pathPattern of mainCheckoutPaths) {
     let match: RegExpExecArray | null

package/src/tools/system/config.ts

@@ -4,8 +4,8 @@ import { homedir } from 'node:os'
 import { parse as parseYaml, stringify } from 'yaml'
 import type { ToolDefinition } from '../../shared/index.ts'
 
-const MIPHAM_DIR = join(homedir(), '.mipham')
-const USER_CONFIG = join(MIPHAM_DIR, 'config.yml')
+const MIPHAM_HOME = join(homedir(), '.mipham')
+const USER_CONFIG = join(MIPHAM_HOME, 'config.yml')
 
 export const configTool: ToolDefinition = {
   name: 'Config',
@@ -26,7 +26,7 @@ export const configTool: ToolDefinition = {
     required: ['action'],
   },
   async execute(params, _ctx) {
-    mkdirSync(MIPHAM_DIR, { recursive: true })
+    mkdirSync(MIPHAM_HOME, { recursive: true })
     const action = params.action as string
 
     let config: Record<string, unknown> = {}

package/src/ui/app.tsx

@@ -14,6 +14,8 @@ import type { SkillsLoader } from '../skills/loader'
 import type { PluginManager } from '../plugin/plugin-manager'
 import { setPreference } from '../config/preferences'
 import { saveProviderApiKey } from '../config/loader'
+import { recordCommand } from '../telemetry/index'
+import { recordCrash } from '../telemetry/crash'
 import { AgentRegistry } from '../agent/agent-registry'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
 import { getMessageRouter, parseMention, resolveRecipientSession } from '../agent/message-router'
@@ -46,6 +48,7 @@ import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import { WorkflowProgress } from './workflow-progress.js'
 import { GoalProgress } from './goal-progress.js'
 import {
+  commandLabelFor,
   getCommand,
   looksLikeSlashCommand,
   parseSlashCommand,
@@ -206,9 +209,13 @@ export function App({
   useEffect(() => {
     if (!gitBranch) return
     let cancelled = false
-    resolveGitPr(gitBranch).then((pr) => {
-      if (!cancelled) setGitPr(pr)
-    })
+    resolveGitPr(gitBranch)
+      .then((pr) => {
+        if (!cancelled) setGitPr(pr)
+      })
+      .catch(() => {
+        /* best effort — the PR badge is decoration, never worth surfacing */
+      })
     return () => {
       cancelled = true
     }
@@ -217,11 +224,15 @@ export function App({
   // 启动后台查新版（非阻塞；离线静默失败）
   useEffect(() => {
     let cancelled = false
-    checkForUpdatesAsync().then((update) => {
-      if (!cancelled && update.available) {
-        setUpdateStatus({ state: 'available', latest: update.latest })
-      }
-    })
+    checkForUpdatesAsync()
+      .then((update) => {
+        if (!cancelled && update.available) {
+          setUpdateStatus({ state: 'available', latest: update.latest })
+        }
+      })
+      .catch(() => {
+        /* offline — silent, per the comment above */
+      })
     return () => {
       cancelled = true
     }
@@ -750,7 +761,7 @@ export function App({
       }
 
       // Turn finished — drain any /loop wakeup queued while we were running.
-      drainLoopQueueRef.current?.(turnId)
+      void drainLoopQueueRef.current?.(turnId)
     },
     [engine, syncBgAgents, config, t],
   )
@@ -794,7 +805,7 @@ export function App({
   useEffect(() => {
     if (wakeupTick === 0) return
     if (isLoading) return
-    drainLoopQueueRef.current?.(turnIdRef.current)
+    void drainLoopQueueRef.current?.(turnIdRef.current)
   }, [wakeupTick, isLoading])
 
   // ── cron poller ──
@@ -850,6 +861,15 @@ export function App({
       if (looksLikeSlashCommand(input)) {
         const { command, args } = parseSlashCommand(input)
 
+        // Counted here rather than at the registry lookup below: /switch, /pick,
+        // /model-picker, /exit, /quit and /focus are special-cased and return
+        // before ever reaching it, so counting there would silently under-report
+        // six of the most-used commands.
+        //
+        // `commandLabelFor` collapses unrecognised names into `/unknown` — see it
+        // for why an unbounded `command_name` is not a cosmetic problem.
+        recordCommand(commandLabelFor(command))
+
         // /switch takes args, handled separately
         if (command === '/switch') {
           const result = await handleSwitch(mkCtx(), args)
@@ -927,6 +947,13 @@ export function App({
           if (result.nextProvider) setProviderId(result.nextProvider)
           if (result.nextModel) setModelId(result.nextModel)
           if (result.exit) process.exit(0)
+          if (result.clearMessages || (result.forwardedMessages?.length ?? 0) > 0) {
+            // The conversation this session is looking at just changed (/clear,
+            // /resume) — the read-before-write record belongs to the old one.
+            // Clearing is the fail-closed direction: an unread file must be
+            // re-read rather than silently overwritten.
+            engine.resetFileTracking()
+          }
           if (result.forwardedMessages && result.forwardedMessages.length > 0) {
             const restored: ChatMessage[] = result.forwardedMessages.map((msg) => ({
               role: msg.role,
@@ -1092,7 +1119,16 @@ export function App({
   }
 
   return (
-    <ErrorBoundary>
+    <ErrorBoundary
+      onError={(error) => {
+        // The boundary's own job is *surviving* a render error — it renders a
+        // fallback and the session continues. But this is the exact failure the
+        // boundary was written for (a frozen layout with a live process, i.e. a
+        // silent hang), so record it as a crash signal rather than letting it
+        // vanish once the fallback paints over the evidence.
+        recordCrash(error, 'render')
+      }}
+    >
       <Box flexDirection="column" padding={1} height="100%">
         {/* Workflow progress — auto-detects active workflows, renders nothing when idle */}
         <WorkflowProgress />