@miphamai/cli 0.85.1 → 0.85.3

package/src/core/session-log.ts

@@ -1,8 +1,9 @@
-import { appendFileSync, readFileSync, mkdirSync, existsSync } from 'node:fs'
+import { mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { createHash } from 'node:crypto'
 import type { Message, ToolUseContent, ToolResultContent, ToolResult } from '../shared/types'
 import type { CheckerDecision } from './post-flight-checker'
+import { appendRegularFileSync, readRegularFileSync } from '../shared/regular-file'
 import { miphamHome } from './paths.ts'
 
 export type SessionEvent =
@@ -117,6 +118,9 @@ export function deriveMessages(events: SessionEvent[]): Message[] {
 
 const LOG_DIR = miphamHome('sessions')
 
+/** 一次性告警：日志路径不是普通文件（写不进去），每个进程只说一句。 */
+let warnedNotAppendable = false
+
 /** 将会话名消毒为安全文件名（与 SessionStore 共用；防路径穿越）。 */
 export function sanitizeSessionName(name: string): string {
   const safe = name.replace(/[^a-zA-Z0-9_-]/g, '_')
@@ -147,22 +151,34 @@ export class SessionLog {
     // Session logs contain full conversation + tool results (possibly credentials):
     // restrict to owner-only (dir 0700, file 0600).
     mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 })
+    const path = join(LOG_DIR, `${sanitizeSessionName(this.name)}.jsonl`)
+    let wrote = 0
     for (const e of this.buf.slice(this.flushed)) {
-      appendFileSync(
-        join(LOG_DIR, `${sanitizeSessionName(this.name)}.jsonl`),
-        JSON.stringify(e) + '\n',
-        { encoding: 'utf-8', mode: 0o600 },
-      )
+      // FIFO/socket 路径上「写不进去」而不是**干等**（`appendFileSync` 会打开目标写）。
+      // 写失败时**不推进** flushed：这些事件还算未落盘，路径恢复后下一次 save 会补上。
+      if (!appendRegularFileSync(path, JSON.stringify(e) + '\n', { mode: 0o600 })) {
+        if (!warnedNotAppendable) {
+          warnedNotAppendable = true
+          process.stderr.write(
+            `⚠ Mipham Code: ${path} is not a regular file — session log events were not written.\n`,
+          )
+        }
+        break
+      }
+      wrote++
     }
-    this.flushed = this.buf.length
+    this.flushed += wrote
   }
 
   /** 从既有 JSONL 打开，逐行解析为事件（已落盘事件标记为已 flush）。 */
   static open(name: string): SessionLog {
     const log = new SessionLog(name)
     const path = join(LOG_DIR, `${sanitizeSessionName(name)}.jsonl`)
-    if (!existsSync(path)) return log
-    for (const line of readFileSync(path, 'utf-8').split('\n')) {
+    // 类型闸在读取之前：`SessionStore.load` 在快照读不出来时**回落到这里**，所以路径上
+    // 是个 FIFO 时不能在这里换个函数继续等 —— 读不动就当空日志（见 shared/regular-file.ts）。
+    const raw = readRegularFileSync(path)
+    if (raw === null) return log
+    for (const line of raw.split('\n')) {
       const trimmed = line.trim()
       if (!trimmed) continue
       try {
@@ -178,6 +194,23 @@ export class SessionLog {
   }
 }
 
+/**
+ * 消息形状闸 —— 投影与**出网**两侧都会解引用的字段的最低门槛，不是 schema 校验。
+ *
+ * 从前这里只查「`message` 是个对象」，于是 `{"type":"user/message","message":{}}`
+ * 一路活到线上：投影照原样收下它，provider 侧读到 `content` 为 `undefined` 走
+ * 「非字符串即 `ContentBlock[]`」那条分支，`.filter` 当场 TypeError（实测）。
+ * `content` 数组里的块同理 —— provider 会 `b.type` 逐个读。
+ */
+export function isValidMessage(m: unknown): boolean {
+  if (!m || typeof m !== 'object') return false
+  const msg = m as Record<string, unknown>
+  if (msg.role !== 'user' && msg.role !== 'assistant' && msg.role !== 'system') return false
+  const content = msg.content
+  if (typeof content === 'string') return true
+  return Array.isArray(content) && content.every((b) => !!b && typeof b === 'object')
+}
+
 /**
  * 事件结构校验 —— 磁盘→内存的**唯一**入口（`open()`）用它挡掉坏行。
  *
@@ -187,6 +220,9 @@ export class SessionLog {
  * 却让投影抛 TypeError（rewrite 那条更狠：`out` 直接变 `undefined`，下一条就炸），
  * 而 `/resume` 那条链上没有 try 兜它。坏行来自手写/拼接/半截重排，不是本进程写的。
  *
+ * 带 message 的事件还要过 `isValidMessage`：投影只把它 `push` 进数组、自己不碰字段，
+ * 所以「投影不许崩」在这里**不够** —— 崩点在下游（provider 分支、UI 的 `msg.role`）。
+ *
  * 不校验 `session/start`、`assistant/chunk`、`checker/decision`：投影对它们无分支；
  * 未知类型一律放行（前向兼容 —— 认不出来不等于要销毁它）。
  */
@@ -197,7 +233,7 @@ function isValidEvent(e: unknown): e is SessionEvent {
   switch (ev.type) {
     case 'user/message':
     case 'assistant/message':
-      return !!ev.message && typeof ev.message === 'object'
+      return isValidMessage(ev.message)
     case 'tool/call':
       return (
         typeof ev.id === 'string' &&
@@ -213,7 +249,8 @@ function isValidEvent(e: unknown): e is SessionEvent {
     case 'compaction/summary':
       return typeof ev.summary === 'string'
     case 'compaction/rewrite':
-      return Array.isArray(ev.messages)
+      // 快照替换：整份投影由它重建 ⇒ 元素形状与 message 事件同罪
+      return Array.isArray(ev.messages) && ev.messages.every(isValidMessage)
     default:
       return true
   }

package/src/core/session-store.ts

@@ -1,17 +1,16 @@
-import {
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-  renameSync,
-  existsSync,
-  statSync,
-} from 'node:fs'
+import { mkdirSync, readdirSync, unlinkSync, existsSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { createHash } from 'node:crypto'
 import type { Message } from '../shared/types'
-import { sanitizeSessionName, SessionLog, deriveMessages, messageToEvents } from './session-log'
+import {
+  sanitizeSessionName,
+  SessionLog,
+  deriveMessages,
+  messageToEvents,
+  isValidMessage,
+} from './session-log'
+import { atomicWriteFileSync } from '../shared/atomic-write'
+import { readRegularFileSync } from '../shared/regular-file'
 import { miphamHome } from './paths.ts'
 
 export interface SessionMetadata {
@@ -54,6 +53,25 @@ function filePath(name: string): string {
   return join(SESSIONS_DIR, `${sanitizeSessionName(name)}.jsonl`)
 }
 
+/**
+ * 旧格式快照（单 JSON 对象 `{metadata, messages}`）的形状闸。
+ *
+ * `'metadata' in parsed` 拦不住 `{"metadata": null, …}` —— `in` 看的是**键在不在**，
+ * 而 `/resume <name>` 紧接着就读 `session.metadata.name`，那条链上没有 try（实测
+ * `TypeError`）。`messages` 的元素同理：`[null]` 会一路送到 UI 的
+ * `forwardedMessages.map((msg) => msg.role)`（`app.tsx:1041`）与 provider 的内容分支。
+ *
+ * 形状不对**整份返回 null**，而不是把坏元素过滤掉：调用方随即回落到事件日志那条路，
+ * 读不出来会如实报 load failed；过滤则会凭空造出一段残缺历史 —— 静默改写用户数据。
+ */
+function asStoredSnapshot(parsed: unknown): StoredSession | null {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  const { metadata, messages } = parsed as { metadata?: unknown; messages?: unknown }
+  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) return null
+  if (!Array.isArray(messages) || !messages.every(isValidMessage)) return null
+  return { metadata: metadata as SessionMetadata, messages: messages as Message[] }
+}
+
 export class SessionStore {
   /**
    * Save a session as JSONL (one JSON object per line).
@@ -79,10 +97,11 @@ export class SessionStore {
       messages,
     }
 
-    // Atomic write: write to temp file, then rename (same-fs rename is atomic)
-    const tmp = path + '.tmp'
-    writeFileSync(tmp, JSON.stringify(session) + '\n', { encoding: 'utf-8', mode: 0o600 })
-    renameSync(tmp, path)
+    // Atomic write: write to temp file, then rename (same-fs rename is atomic).
+    // 临时名由 atomicWriteFileSync 生成（pid + 随机后缀）—— 从前这里是固定的
+    // `path + '.tmp'`，两个进程同时存同一个会话时，先 rename 的那个会把**后一个**写者的
+    // 内容搬进目标，而它自己的 rename 再抛 ENOENT：在一个「目标永不半截」的函数里丢一次写。
+    atomicWriteFileSync(path, JSON.stringify(session) + '\n', { mode: 0o600 })
 
     // Incremental index update — only touch this session's entry
     try {
@@ -123,18 +142,12 @@ export class SessionStore {
   /** 从磁盘重开一个 SessionLog（不存在返回空 log）。旧格式快照自动迁移为事件日志。 */
   static loadLog(name: string): SessionLog {
     const path = filePath(name)
-    if (!existsSync(path)) return SessionLog.open(name)
     try {
-      const raw = readFileSync(path, 'utf-8')
-      const parsed = JSON.parse(raw) as unknown
-      if (
-        parsed &&
-        typeof parsed === 'object' &&
-        'metadata' in parsed &&
-        Array.isArray((parsed as { messages?: unknown }).messages)
-      ) {
+      const raw = readRegularFileSync(path)
+      if (raw === null) return SessionLog.open(name)
+      const old = asStoredSnapshot(JSON.parse(raw))
+      if (old) {
         // 旧格式快照 → 迁移为事件日志（重写文件，避免后续 append 混格式）
-        const old = parsed as StoredSession
         const log = new SessionLog(name)
         log.append({
           type: 'session/start',
@@ -160,19 +173,12 @@ export class SessionStore {
    */
   static load(name: string): StoredSession | null {
     const path = filePath(name)
-    if (!existsSync(path)) return null
-
     try {
-      const raw = readFileSync(path, 'utf-8')
-      // 旧格式：单 JSON 对象 {metadata, messages}
-      const parsed = JSON.parse(raw) as unknown
-      if (
-        parsed &&
-        typeof parsed === 'object' &&
-        'metadata' in parsed &&
-        Array.isArray((parsed as { messages?: unknown }).messages)
-      ) {
-        return parsed as StoredSession
+      const raw = readRegularFileSync(path)
+      if (raw !== null) {
+        // 旧格式：单 JSON 对象 {metadata, messages}
+        const old = asStoredSnapshot(JSON.parse(raw))
+        if (old) return old
       }
     } catch {
       // 多行 JSONL → 新格式，走事件解析
@@ -295,7 +301,7 @@ export class SessionStore {
       }
     }
 
-    writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), { encoding: 'utf-8', mode: 0o600 })
+    atomicWriteFileSync(INDEX_FILE, JSON.stringify(index, null, 2), { mode: 0o600 })
   }
 
   /**
@@ -323,7 +329,7 @@ export class SessionStore {
     } else {
       index.push(entry)
     }
-    writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), { encoding: 'utf-8', mode: 0o600 })
+    atomicWriteFileSync(INDEX_FILE, JSON.stringify(index, null, 2), { mode: 0o600 })
   }
 
   /**
@@ -340,8 +346,7 @@ export class SessionStore {
         ? `${safeRaw.slice(0, 80)}-${createHash('sha256').update(safeRaw).digest('hex').slice(0, 16)}`
         : safeRaw
     const summaryPath = join(SUMMARIES_DIR, `${safe}.md`)
-    writeFileSync(summaryPath, `# ${name}\n\n${summary}\n\nTags: ${tags.join(', ')}\n`, {
-      encoding: 'utf-8',
+    atomicWriteFileSync(summaryPath, `# ${name}\n\n${summary}\n\nTags: ${tags.join(', ')}\n`, {
       mode: 0o600,
     })
 
@@ -365,7 +370,7 @@ export class SessionStore {
           tags,
         })
       }
-      writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), { encoding: 'utf-8', mode: 0o600 })
+      atomicWriteFileSync(INDEX_FILE, JSON.stringify(index, null, 2), { mode: 0o600 })
     } catch {
       // Index write is best-effort
     }
@@ -414,11 +419,26 @@ export class SessionStore {
 
   /**
    * Read the raw index file, returning empty array if missing or corrupt.
+   *
+   * 「corrupt」不只是语法错：`null`、`{"a":1}`、`[1,2]` 都过得了 `JSON.parse`。放它们
+   * 过去，`getLatest()` 会按数组用它 —— `null` 在启动路径（`index.tsx` 建系统提示时）
+   * 抛 `TypeError: index.length`；`[1,2]` 更安静：`getLatest()` 返回数字 `1`，调用方接着
+   * 读 `latest.name` 拿到 `undefined`，再喂给 `load()` ⇒ `name.replace` 抛。条目还必须
+   * 有**字符串 name**：索引条目的第一用途就是当文件名用。
    */
   private static loadIndexRaw(): SessionIndexEntry[] {
-    if (!existsSync(INDEX_FILE)) return []
+    const raw = readRegularFileSync(INDEX_FILE)
+    if (raw === null) return []
     try {
-      return JSON.parse(readFileSync(INDEX_FILE, 'utf-8'))
+      const parsed: unknown = JSON.parse(raw)
+      if (!Array.isArray(parsed)) return []
+      return parsed.filter(
+        (e): e is SessionIndexEntry =>
+          !!e &&
+          typeof e === 'object' &&
+          typeof (e as { name?: unknown }).name === 'string' &&
+          (e as { name: string }).name.length > 0,
+      )
     } catch {
       return []
     }

package/src/daemon/attach-protocol.ts

@@ -1,6 +1,9 @@
 // apps/cli/src/daemon/attach-protocol.ts
-// Client → Daemon: prompt, interrupt
-// Daemon → Client: text, tool_use, tool_result, usage, task_notification, done, error, session_state
+// Client → Daemon: prompt, interrupt, set_mode
+// Daemon → Client: text, tool_use, tool_result, usage, task_notification, done, error,
+//                  session_state, mode
+
+import type { PermissionMode } from '../shared/types'
 
 export interface ClientPromptMessage {
   type: 'prompt'
@@ -11,7 +14,18 @@ export interface ClientInterruptMessage {
   type: 'interrupt'
   sessionId: string
 }
-export type ClientMessage = ClientPromptMessage | ClientInterruptMessage
+export interface ClientSetModeMessage {
+  type: 'set_mode'
+  sessionId: string
+  /**
+   * 请求的档位。daemon 会先过白名单、再走组织级限制的钳制，然后回播**生效**的那一档。
+   *
+   * `sessionId` 与 `prompt` / `interrupt` 一样是协议对称用的：daemon 一概以
+   * `ws.data.sessionId` 为准（否则一个 attach 就能改**别的**会话的闸门）。
+   */
+  mode: PermissionMode
+}
+export type ClientMessage = ClientPromptMessage | ClientInterruptMessage | ClientSetModeMessage
 
 export interface ServerTextMessage {
   type: 'text'
@@ -61,6 +75,18 @@ export interface ServerSessionStateMessage {
   provider: string
   model: string
   turnCount: number
+  /** 本会话当前**生效**的档位 —— 新 attach 的客户端据此初始化页脚，而不是猜 `default`。 */
+  mode: PermissionMode
+}
+/**
+ * 回播生效档位。两个触发点：客户端发来 `set_mode`（含被拒的请求 —— 那时回播的是
+ * **当前**档），以及 `set_mode` 施加后。带的是 `PermissionSystem.getMode()` 的读数，
+ * 即**钳制之后**的值：报请求值就是那条老缺陷的形状 —— 说放行、实际审批。
+ */
+export interface ServerModeMessage {
+  type: 'mode'
+  sessionId: string
+  mode: PermissionMode
 }
 
 export type ServerMessage =
@@ -72,3 +98,4 @@ export type ServerMessage =
   | ServerDoneMessage
   | ServerErrorMessage
   | ServerSessionStateMessage
+  | ServerModeMessage

package/src/daemon/auth.ts

@@ -1,6 +1,7 @@
 // apps/cli/src/daemon/auth.ts
 import { randomBytes, timingSafeEqual } from 'node:crypto'
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { readFileSync, existsSync, mkdirSync } from 'node:fs'
+import { atomicWriteFileSync } from '../shared/atomic-write'
 import { dirname } from 'node:path'
 
 /**
@@ -21,7 +22,7 @@ export function loadOrCreateToken(tokenPath: string): string {
 
   const token = generateToken()
   mkdirSync(dirname(tokenPath), { recursive: true, mode: 0o700 })
-  writeFileSync(tokenPath, token, { mode: 0o600 })
+  atomicWriteFileSync(tokenPath, token, { mode: 0o600 })
   return token
 }
 
@@ -51,7 +52,7 @@ export function verifyToken(expected: string, provided: string): boolean {
  */
 export function rotateToken(tokenPath: string): string {
   const token = generateToken()
-  writeFileSync(tokenPath, token, { mode: 0o600 })
+  atomicWriteFileSync(tokenPath, token, { mode: 0o600 })
   return token
 }
 

package/src/daemon/index.ts

@@ -6,7 +6,8 @@
 // getPort()      reads the last known port from disk
 
 import { join } from 'node:path'
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs'
+import { existsSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs'
+import { atomicWriteFileSync } from '../shared/atomic-write'
 import { createServer as createNetServer } from 'node:net'
 import type { Server } from 'bun'
 import { DaemonDatabase } from './database'
@@ -247,8 +248,8 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
   activeServer = server
 
   // Write PID and port files
-  writeFileSync(PID_FILE, String(process.pid))
-  writeFileSync(PORT_FILE, String(port))
+  atomicWriteFileSync(PID_FILE, String(process.pid), { mode: 0o644 })
+  atomicWriteFileSync(PORT_FILE, String(port), { mode: 0o644 })
 
   return { port, token }
 }