@miphamai/cli 0.81.7 → 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,7 +1,8 @@
-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_HOME = join(homedir(), '.mipham')
@@ -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/commands.ts

@@ -5191,10 +5191,23 @@ const artifactOpenCmd: CommandHandler = async (ctx, args) => {
     return { content: 'Usage: /artifact open <name>\nExample: /artifact open dashboard' }
   }
 
-  const sessionId = 'session-1' // default session
-  const port = 9876
-  const ext = name.endsWith('.svg') ? '' : '.html'
-  const url = `http://localhost:${port}/${sessionId}/${name}${ext}`
+  const { readManifest } = await import('../artifacts/manifest')
+  const { artifactsRoot } = await import('../artifacts/paths')
+  const manifest = readManifest(artifactsRoot(process.cwd()))
+
+  // 先找本会话，再退到任意会话：文件在磁盘上跨会话留存，而 `open` 是用户手敲的。
+  // 原先写死 `session-1` + 端口 9876，工具回报的却是真会话 id 和**实际**端口
+  // （服务端遇到端口占用会自增），所以这条命令从构造上就打不开任何东西。
+  const entry =
+    manifest.artifacts.find((a) => a.name === name && a.sessionId === ctx.sessionId) ??
+    manifest.artifacts.find((a) => a.name === name)
+
+  if (!entry) {
+    return { content: `✗ No artifact named "${name}". Run /artifact list to see them.` }
+  }
+
+  // 用工具落盘时记下的 URL —— 那就是它印给用户的同一个坐标，两边不该各算一次。
+  const url = entry.url
 
   try {
     await openBrowser(url)
@@ -5204,13 +5217,14 @@ const artifactOpenCmd: CommandHandler = async (ctx, args) => {
   }
 }
 
-const artifactListCmd: CommandHandler = async (_ctx, _args) => {
-  const { getSessionArtifacts } = await import('../artifacts/manifest')
-  const { join } = await import('node:path')
-  const { ARTIFACTS_DIR } = await import('../shared/constants')
+const artifactListCmd: CommandHandler = async (ctx, _args) => {
+  const { readManifest, getSessionArtifacts } = await import('../artifacts/manifest')
+  const { artifactsRoot } = await import('../artifacts/paths')
 
-  const dir = join(process.cwd(), ARTIFACTS_DIR)
-  const entries = getSessionArtifacts(dir, 'session-1')
+  const dir = artifactsRoot(process.cwd())
+  // 会话 id 取自真实上下文，不是写死的 'session-1' —— 工具落盘时写的是真 id，
+  // 写死的那一支必然过滤出空列表。
+  const entries = getSessionArtifacts(dir, ctx.sessionId)
 
   if (entries.length === 0) {
     return {
@@ -5226,7 +5240,9 @@ const artifactListCmd: CommandHandler = async (_ctx, _args) => {
     )
   }
   lines.push('', `  ${entries.length} artifact(s) — /artifact open <name> to view`)
-  lines.push(`  Gallery: http://localhost:9876`)
+  // 画廊端口同样不写死：用最近一次落盘记下的那个（服务端会因端口占用自增）。
+  const { port } = readManifest(dir)
+  if (port) lines.push(`  Gallery: http://localhost:${port}`)
 
   return { content: lines.join('\n') }
 }

package/src/artifacts/versioning.ts

@@ -1,127 +0,0 @@
-import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-
-const DEFAULT_VERSIONS_DIR = join(homedir(), '.mipham', 'artifacts')
-
-export interface ArtifactVersion {
-  name: string
-  version: number
-  path: string
-  createdAt: string
-  size: number
-}
-
-/**
- * Manages artifact version snapshots on disk.
- *
- * Directory layout:
- *   <dir>/<name>/versions/v1.html
- *   <dir>/<name>/versions/v2.html
- *   <dir>/<name>/current.html     (latest snapshot)
- *   <dir>/<name>/manifest.json    ({ name, currentVersion, versionCount })
- */
-export class ArtifactVersioning {
-  private dir: string
-
-  constructor(dir?: string) {
-    this.dir = dir ?? DEFAULT_VERSIONS_DIR
-    mkdirSync(this.dir, { recursive: true })
-  }
-
-  /** Save a new version of an artifact. Returns the assigned version number. */
-  saveVersion(name: string, content: string): number {
-    const artifactDir = join(this.dir, name)
-    const versionsDir = join(artifactDir, 'versions')
-    mkdirSync(versionsDir, { recursive: true })
-
-    // Determine next version number
-    const existing = this.listVersions(name)
-    const nextVersion = (existing.length > 0 ? Math.max(...existing.map((v) => v.version)) : 0) + 1
-
-    // Save versioned file
-    const versionPath = join(versionsDir, `v${nextVersion}.html`)
-    writeFileSync(versionPath, content, 'utf-8')
-
-    // Update current.html
-    writeFileSync(join(artifactDir, 'current.html'), content, 'utf-8')
-
-    // Update manifest
-    writeFileSync(
-      join(artifactDir, 'manifest.json'),
-      JSON.stringify(
-        {
-          name,
-          currentVersion: nextVersion,
-          versionCount: nextVersion,
-        },
-        null,
-        2,
-      ),
-    )
-
-    return nextVersion
-  }
-
-  /** List all saved versions for an artifact, newest first. */
-  listVersions(name: string): ArtifactVersion[] {
-    const versionsDir = join(this.dir, name, 'versions')
-    if (!existsSync(versionsDir)) return []
-
-    try {
-      return readdirSync(versionsDir)
-        .filter((f) => f.startsWith('v') && f.endsWith('.html'))
-        .map((f) => {
-          const vNum = parseInt(f.replace('v', '').replace('.html', ''), 10)
-          const path = join(versionsDir, f)
-          const stat = statSync(path)
-          return {
-            name,
-            version: vNum,
-            path,
-            createdAt: stat.birthtime.toISOString(),
-            size: stat.size,
-          }
-        })
-        .sort((a, b) => b.version - a.version)
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Get artifact content.
-   * - If a version number is given, returns that specific version.
-   * - Otherwise returns the latest (current.html).
-   * Returns null if the requested version does not exist.
-   */
-  getVersion(name: string, version?: number): string | null {
-    const artifactDir = join(this.dir, name)
-
-    if (version !== undefined) {
-      const vPath = join(artifactDir, 'versions', `v${version}.html`)
-      return existsSync(vPath) ? readFileSync(vPath, 'utf-8') : null
-    }
-
-    const currentPath = join(artifactDir, 'current.html')
-    return existsSync(currentPath) ? readFileSync(currentPath, 'utf-8') : null
-  }
-
-  /** Produce a simple line-by-line text diff between two versions. */
-  diff(name: string, v1: number, v2: number): string {
-    const content1 = this.getVersion(name, v1) || ''
-    const content2 = this.getVersion(name, v2) || ''
-    const lines1 = content1.split('\n')
-    const lines2 = content2.split('\n')
-
-    const diffLines: string[] = []
-    const maxLen = Math.max(lines1.length, lines2.length)
-    for (let i = 0; i < maxLen; i++) {
-      if (lines1[i] !== lines2[i]) {
-        if (lines1[i] !== undefined) diffLines.push(`- ${lines1[i]}`)
-        if (lines2[i] !== undefined) diffLines.push(`+ ${lines2[i]}`)
-      }
-    }
-    return diffLines.length > 0 ? diffLines.join('\n') : '(no changes)'
-  }
-}