@miphamai/cli 0.81.6 → 0.81.8

package/src/tools/file/read.ts

@@ -1,4 +1,4 @@
-import { readFileSync, fstatSync, closeSync, constants } from 'node:fs'
+import { readFileSync, readSync, fstatSync, closeSync, constants } from 'node:fs'
 import type { ToolDefinition, CredentialMaskingConfig } from '../../shared/index.ts'
 import { resolveSafe } from '../../security/path'
 import { openNoFollow, isSymlinkLoop } from '../../security/fd'
@@ -6,6 +6,115 @@ import type { Service } from '../../vajra'
 import { toolKey } from '../seam'
 import { withValidation } from '../validation'
 
+/** Lines returned when the caller passes no `limit`. */
+const DEFAULT_LIMIT = 2000
+
+/** Bytes per syscall while scanning for newlines. */
+const CHUNK_BYTES = 64 * 1024
+
+/**
+ * How far a single Read may scan to locate the requested lines. Lines are
+ * addressed by index, so finding line N means scanning everything before it;
+ * this is what keeps that scan from turning a request for two lines of a 2 GB
+ * file into a 2 GB read.
+ */
+const MAX_SCAN_BYTES = 50_000_000
+
+/** Render a line window the way the tool reports it: `   123\ttext`. */
+function formatLines(lines: string[], offset: number): string {
+  return lines.map((l, i) => `${String(offset + i + 1).padStart(6, ' ')}\t${l}`).join('\n')
+}
+
+/**
+ * Lines `[offset, offset + limit)` of an already-decoded string.
+ *
+ * Scans newlines instead of `content.split('\n')`, which materializes one JS
+ * string for *every* line of the file in order to return `limit` of them. On a
+ * 20 MB source, returning 2000 lines that way cost +34 MB of heap for 60-char
+ * lines and +100 MB for 3-char lines (333k vs 10M lines — it tracks line count,
+ * not bytes); scanning costs ~0 on top of the string it is handed.
+ */
+function windowFromString(content: string, offset: number, limit: number): string[] {
+  const out: string[] = []
+  let lineNo = 0
+  let start = 0
+  while (out.length < limit) {
+    const nl = content.indexOf('\n', start)
+    const end = nl === -1 ? content.length : nl
+    if (lineNo >= offset) out.push(content.slice(start, end))
+    lineNo++
+    if (nl === -1) break
+    start = nl + 1
+  }
+  return out
+}
+
+/**
+ * Lines `[offset, offset + limit)` read from `fd` — only those lines are ever
+ * materialized, so cost tracks the window rather than the file: a 2000-line
+ * window of a 20 MB file leaves RSS at the process baseline (~38 MB), where
+ * reading the file whole and slicing it cost 142–255 MB.
+ *
+ * Two passes over the same bytes: the first only *looks* for newline bytes to
+ * learn where the window starts and ends, the second reads exactly that byte
+ * range and decodes it once. Scanning raw bytes is safe because `0x0a` never
+ * occurs inside a multi-byte UTF-8 sequence (continuation bytes are >= 0x80),
+ * and the decoded range starts and ends on a newline — so neither pass can split
+ * a character. Returns null when the window cannot be located within
+ * `MAX_SCAN_BYTES`.
+ */
+function windowFromFd(fd: number, offset: number, limit: number): string[] | null {
+  if (limit <= 0) return []
+
+  const buf = Buffer.allocUnsafe(CHUNK_BYTES)
+  let scanned = 0 // bytes consumed by the scan
+  let lineNo = 0
+  let windowStart = offset <= 0 ? 0 : -1
+  let windowEnd = -1
+  let eof = false
+
+  while (windowEnd === -1 && scanned < MAX_SCAN_BYTES) {
+    const n = readSync(fd, buf, 0, buf.length, scanned)
+    if (n <= 0) {
+      eof = true
+      break
+    }
+    const lastNl = buf.lastIndexOf(0x0a, n - 1)
+    if (lastNl !== -1) {
+      let from = 0
+      for (;;) {
+        const nl = buf.indexOf(0x0a, from)
+        if (nl === -1 || nl > lastNl) break
+        lineNo++ // line `lineNo - 1` ends at this newline
+        if (lineNo === offset) windowStart = scanned + nl + 1
+        if (lineNo === offset + limit) {
+          windowEnd = scanned + nl
+          break
+        }
+        from = nl + 1
+      }
+    }
+    scanned += n
+  }
+
+  if (windowEnd === -1) {
+    // Either the file ended (the window is everything that is left) or the scan
+    // budget ran out before the window's last line was reached.
+    if (!eof) return null
+    windowEnd = scanned
+  }
+  if (windowStart === -1) return [] // `offset` is past the end of the file
+
+  const out = Buffer.allocUnsafe(windowEnd - windowStart)
+  let got = 0
+  while (got < out.length) {
+    const n = readSync(fd, out, got, out.length - got, windowStart + got)
+    if (n <= 0) break
+    got += n
+  }
+  return out.toString('utf-8', 0, got).split('\n')
+}
+
 export function createReadTool(credentialConfig?: CredentialMaskingConfig): ToolDefinition {
   return {
     name: 'Read',
@@ -40,59 +149,56 @@ export function createReadTool(credentialConfig?: CredentialMaskingConfig): Tool
         throw err
       }
 
-      let content: string
       try {
-        const stat = fstatSync(fd)
-        if (stat.isDirectory()) {
+        if (fstatSync(fd).isDirectory()) {
           return { success: false, content: '', error: `Path is a directory: ${filePath}` }
         }
-        // Prevent OOM on single-line files (e.g. 500MB JSON blob)
-        const MAX_FILE_SIZE = 50_000_000 // 50 MB
-        if (stat.size > MAX_FILE_SIZE) {
-          return {
-            success: false,
-            content: '',
-            error: `File too large (${(stat.size / 1e6).toFixed(1)} MB). Max: 50 MB. Use offset/limit for large files.`,
+
+        const offset = (params.offset as number) || 0
+        const limit = (params.limit as number) || DEFAULT_LIMIT
+
+        // ── Credential masking ──
+        // The rule matches on path alone, so this is decided before any read: a
+        // masked file needs its whole content (the mask is content-shaped), while
+        // every other file is served straight from the fd. Reading the file
+        // *first* is what used to make `offset`/`limit` useless on large files —
+        // the size check ran before the window was ever applied.
+        let result: string | null = null
+        if (credentialConfig) {
+          const { matchCredentialFile, maskContent, CREDENTIAL_SENTINEL } =
+            await import('../../core/credential-masker')
+          const rule = matchCredentialFile(filePath, credentialConfig)
+          if (rule) {
+            const masked = maskContent(readFileSync(fd, 'utf-8'), rule)
+            // Full-file mask: return the sentinel immediately (offset/limit don't apply)
+            result =
+              masked === CREDENTIAL_SENTINEL
+                ? masked
+                : formatLines(windowFromString(masked, offset, limit), offset)
           }
         }
-        content = readFileSync(fd, 'utf-8')
-      } finally {
-        closeSync(fd)
-      }
 
-      const offset = (params.offset as number) || 0
-      const limit = (params.limit as number) || 2000
-
-      // ── Read tracking: mark file as read for Write tool safety ──
-      ctx.readFiles?.add(filePath)
-
-      // ── Credential masking ──
-      if (credentialConfig) {
-        const { matchCredentialFile, maskContent, CREDENTIAL_SENTINEL } =
-          await import('../../core/credential-masker')
-        const rule = matchCredentialFile(filePath, credentialConfig)
-        if (rule) {
-          const masked = maskContent(content, rule)
-          // Full-file mask: return sentinel immediately (offset/limit don't apply)
-          if (masked === CREDENTIAL_SENTINEL) {
-            return { success: true, content: masked }
+        if (result === null) {
+          const lines = windowFromFd(fd, offset, limit)
+          if (lines === null) {
+            return {
+              success: false,
+              content: '',
+              error:
+                `File too large: scanned ${MAX_SCAN_BYTES / 1e6} MB without reaching the end of lines ` +
+                `${offset}–${offset + limit - 1}. Narrow the range (smaller offset or limit), or use a ` +
+                `shell tool to slice the file.`,
+            }
           }
-          // Extract mode: apply offset/limit on masked content
-          const maskedLines = masked.split('\n')
-          const maskedSlice = maskedLines.slice(offset, offset + limit)
-          const maskedResult = maskedSlice
-            .map((l, i) => `${String(offset + i + 1).padStart(6, ' ')}\t${l}`)
-            .join('\n')
-          return { success: true, content: maskedResult }
+          result = formatLines(lines, offset)
         }
-      }
 
-      const lines = content.split('\n')
-      const slice = lines.slice(offset, offset + limit)
-      const result = slice
-        .map((l, i) => `${String(offset + i + 1).padStart(6, ' ')}\t${l}`)
-        .join('\n')
-      return { success: true, content: result }
+        // ── Read tracking: mark file as read for Write tool safety ──
+        ctx.readFiles?.add(filePath)
+        return { success: true, content: result }
+      } finally {
+        closeSync(fd)
+      }
     },
   }
 }

package/src/tools/scheduling/cron.ts

@@ -26,14 +26,31 @@ export interface CronJob {
   createdAt: string
   nextFire: string
   lastFired: string | null
+  /**
+   * The directory this job belongs to. The store is global (`~/.mipham/cron/`)
+   * and every session's poller reads all of it, so without this a job created in
+   * project A gets executed by whichever session in project B happens to be
+   * running — its prompt expands against the wrong codebase.
+   *
+   * Optional because files written before this field existed genuinely lack it;
+   * the poller treats a missing `cwd` as "any directory" so those keep firing.
+   */
+  cwd?: string
+  /** Session that created the job. Informational — the poller keys on `cwd`. */
+  sessionId?: string
 }
 
 function jobPath(id: string): string {
   return join(CRON_DIR, `${id}.json`)
 }
 
-function generateId(cron: string, prompt: string): string {
-  return createHash('sha256').update(`${cron}:${prompt}`).digest('hex').slice(0, 12)
+/**
+ * Job id includes `cwd`: keyed on `cron:prompt` alone, creating the same schedule
+ * in two directories wrote to the same file and the second silently replaced the
+ * first.
+ */
+function generateId(cron: string, prompt: string, cwd: string): string {
+  return createHash('sha256').update(`${cwd}:${cron}:${prompt}`).digest('hex').slice(0, 12)
 }
 
 /**
@@ -101,11 +118,11 @@ export const cronCreateTool: ToolDefinition = {
     },
     required: ['cron', 'prompt'],
   },
-  async execute(params, _ctx) {
+  async execute(params, ctx) {
     const cron = params.cron as string
     const prompt = params.prompt as string
     const recurring = params.recurring !== false
-    const id = generateId(cron, prompt)
+    const id = generateId(cron, prompt, ctx.cwd)
 
     const now = new Date()
     const job: CronJob = {
@@ -116,6 +133,8 @@ export const cronCreateTool: ToolDefinition = {
       createdAt: now.toISOString(),
       nextFire: computeNextFire(cron, now),
       lastFired: null,
+      cwd: ctx.cwd,
+      sessionId: ctx.sessionId,
     }
 
     writeJob(job)
@@ -127,6 +146,7 @@ export const cronCreateTool: ToolDefinition = {
         `Created ${type} cron job.\n` +
         `ID: ${id}\n` +
         `Schedule: ${cron}\n` +
+        `Scoped to: ${ctx.cwd}\n` +
         `Prompt: "${prompt.slice(0, 80)}${prompt.length > 80 ? '...' : ''}"`,
     }
   },
@@ -182,11 +202,20 @@ export const cronListTool: ToolDefinition = {
     const lines = [`── Scheduled Cron Jobs (${jobs.length}) ──`, '']
     for (const j of jobs) {
       const type = j.recurring ? 'recurring' : 'one-shot'
-      lines.push(`${j.id}  ${j.cron}  ${type}`)
+      // 目录要看得见：任务被限定在建立它的那个目录，从别的项目 `/schedule` 列出来时
+      // 用户得能看出它为什么不在自己这里跑。**没有 cwd 的旧文件恰恰相反** —— 它在任何
+      // 目录都会执行，而这里是唯一能看见那件事的地方，所以必须显式标出来（留空等于
+      // 把「无归属」显示成「和别的任务一样」）。
+      lines.push(`${j.id}  ${j.cron}  ${type}  ${j.cwd ? `[${j.cwd}]` : '[无归属]'}`)
       lines.push(`  ${j.prompt.slice(0, 100)}`)
       lines.push('')
     }
 
+    if (jobs.some((j) => !j.cwd)) {
+      lines.push('⚠️ [无归属] 是加 cwd 字段之前写的任务：没有目录可判，任何项目里都会执行。')
+      lines.push('   消除办法：在目标目录里用 CronCreate 重建，或让 Mipham 用 CronDelete 删掉。')
+    }
+
     return { success: true, content: lines.join('\n') }
   },
 }

package/src/tools/system/config.ts

@@ -1,11 +1,12 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { readFileSync, existsSync, mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { parse as parseYaml, stringify } from 'yaml'
+import { atomicWriteFileSync } from '../../shared/atomic-write'
 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 +27,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> = {}
@@ -60,7 +61,10 @@ export const configTool: ToolDefinition = {
         obj = obj[k] as Record<string, unknown>
       }
       obj[keys[keys.length - 1]!] = params.value
-      writeFileSync(USER_CONFIG, stringify(config), 'utf-8')
+      // 原子写 + 0o600：这是整份 read-modify-write，裸 writeFileSync 原地截断 ——
+      // 崩在写中途就留下半截 YAML，而权限由 umask 决定（典型 0644），比同一份配置的
+      // 另一个写者 saveProviderApiKey（loader.ts，0600 原子写）更松。
+      atomicWriteFileSync(USER_CONFIG, stringify(config), { mode: 0o600 })
       return { success: true, content: `Set ${key} = ${params.value}` }
     }
 

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)
@@ -1099,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 />