@muyichengshayu/promptx 0.2.8 → 0.2.9

package/apps/server/src/agentSessionDiscovery.js

@@ -602,3 +602,139 @@ export function listKnownOpenCodeSessions(options = {}) {
 
   return sortAndLimitCandidates(items, options)
 }
+
+function getKimiHomeDir(options = {}) {
+  return normalizeText(options.kimiHome || process.env.KIMI_HOME)
+    || path.join(os.homedir(), '.kimi')
+}
+
+function readKimiJson(options = {}) {
+  const kimiJsonPath = path.join(getKimiHomeDir(options), 'kimi.json')
+  return parseJson(safeReadFile(kimiJsonPath)) || {}
+}
+
+function readKimiContextPreview(contextPath = '') {
+  const content = safeReadFile(contextPath, 256 * 1024)
+  if (!content) {
+    return ''
+  }
+
+  const lines = content.replace(/\r\n/g, '\n').split('\n').slice(0, 30)
+  for (const line of lines) {
+    const event = parseJson(line)
+    if (!event) {
+      continue
+    }
+
+    const role = normalizeText(event.role).toLowerCase()
+    if (role !== 'user') {
+      continue
+    }
+
+    const text = extractMessageText(event)
+    if (text) {
+      return text.replace(/\s+/g, ' ').slice(0, MAX_PREVIEW_LENGTH)
+    }
+  }
+
+  return ''
+}
+
+export function listKnownKimiCodeSessions(options = {}) {
+  const kimiHome = getKimiHomeDir(options)
+  const items = []
+
+  const kimiJson = readKimiJson(options)
+  const cwdBySessionId = new Map()
+
+  if (kimiJson?.work_dirs && Array.isArray(kimiJson.work_dirs)) {
+    kimiJson.work_dirs.forEach((entry) => {
+      const id = normalizeText(entry?.last_session_id)
+      const cwd = normalizeText(entry?.path)
+      if (!id || !cwd) {
+        return
+      }
+
+      cwdBySessionId.set(id, cwd)
+      items.push({
+        id,
+        engine: AGENT_ENGINES.KIMI_CODE,
+        label: path.basename(cwd) || id,
+        cwd,
+        updatedAt: safeStat(path.join(kimiHome, 'kimi.json'))?.mtime,
+        source: 'kimi_json',
+      })
+    })
+  }
+
+  const sessionsDir = path.join(kimiHome, 'sessions')
+  if (safeStat(sessionsDir)?.isDirectory()) {
+    let hashDirs = []
+    try {
+      hashDirs = fs.readdirSync(sessionsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+    } catch {
+      hashDirs = []
+    }
+
+    for (const hashDir of hashDirs) {
+      const hashDirPath = path.join(sessionsDir, hashDir)
+      let sessionDirs = []
+      try {
+        sessionDirs = fs.readdirSync(hashDirPath, { withFileTypes: true })
+          .filter((entry) => entry.isDirectory())
+          .map((entry) => entry.name)
+      } catch {
+        continue
+      }
+
+      for (const sessionId of sessionDirs) {
+        if (cwdBySessionId.has(sessionId)) {
+          const statePath = path.join(hashDirPath, sessionId, 'state.json')
+          const state = parseJson(safeReadFile(statePath))
+          if (state?.archived) {
+            const index = items.findIndex((item) => item.id === sessionId)
+            if (index >= 0) {
+              items.splice(index, 1)
+            }
+            continue
+          }
+
+          const contextPath = path.join(hashDirPath, sessionId, 'context.jsonl')
+          const preview = readKimiContextPreview(contextPath)
+          const stateStat = safeStat(statePath)
+          const existing = items.find((item) => item.id === sessionId)
+          if (existing) {
+            existing.label = normalizeText(state?.custom_title) || preview || existing.label
+            if (stateStat?.mtime && getSortTime(stateStat.mtime) > getSortTime(existing.updatedAt)) {
+              existing.updatedAt = toIsoDate(stateStat.mtime)
+              existing.updatedAtSource = 'explicit'
+            }
+          }
+          continue
+        }
+
+        const statePath = path.join(hashDirPath, sessionId, 'state.json')
+        const state = parseJson(safeReadFile(statePath))
+        if (state?.archived) {
+          continue
+        }
+
+        const contextPath = path.join(hashDirPath, sessionId, 'context.jsonl')
+        const preview = readKimiContextPreview(contextPath)
+
+        items.push({
+          id: sessionId,
+          engine: AGENT_ENGINES.KIMI_CODE,
+          label: normalizeText(state?.custom_title) || preview || sessionId,
+          cwd: '',
+          updatedAt: safeStat(statePath)?.mtime,
+          source: 'kimi_sessions',
+        })
+      }
+    }
+  }
+
+  return sortAndLimitCandidates(items, options)
+}

package/apps/server/src/agentSessionDiscovery.test.js

@@ -7,6 +7,7 @@ import test from 'node:test'
 import {
   decodeClaudeProjectPath,
   listKnownClaudeCodeSessions,
+  listKnownKimiCodeSessions,
   listKnownOpenCodeSessions,
 } from './agentSessionDiscovery.js'
 
@@ -125,3 +126,61 @@ test('listKnownOpenCodeSessions discovers sessions from desktop dat files', () =
     fs.rmSync(tempRoot, { recursive: true, force: true })
   }
 })
+
+test('listKnownKimiCodeSessions merges kimi.json work dirs with session state', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-kimi-discovery-'))
+  const kimiHome = path.join(tempRoot, '.kimi')
+  const sessionDir = path.join(kimiHome, 'sessions', 'hash-1', 'kimi-session-1')
+  fs.mkdirSync(sessionDir, { recursive: true })
+
+  const kimiJsonPath = path.join(kimiHome, 'kimi.json')
+  const statePath = path.join(sessionDir, 'state.json')
+  const contextPath = path.join(sessionDir, 'context.jsonl')
+  const kimiJsonTime = new Date('2026-04-13T08:00:00.000Z')
+  const stateTime = new Date('2026-04-13T09:00:00.000Z')
+
+  fs.writeFileSync(kimiJsonPath, JSON.stringify({
+    work_dirs: [
+      {
+        path: '/Users/bravf/code/promptx',
+        last_session_id: 'kimi-session-1',
+      },
+    ],
+  }))
+  fs.writeFileSync(statePath, JSON.stringify({
+    custom_title: '继续 Kimi 项目',
+  }))
+  fs.writeFileSync(contextPath, `${JSON.stringify({ role: 'user', content: '帮我修复 Kimi 接入' })}\n`)
+  fs.utimesSync(kimiJsonPath, kimiJsonTime, kimiJsonTime)
+  fs.utimesSync(statePath, stateTime, stateTime)
+
+  try {
+    const items = listKnownKimiCodeSessions({
+      kimiHome,
+      limit: 10,
+      cwd: '/Users/bravf/code/promptx',
+    })
+
+    assert.equal(items.length, 1)
+    assert.deepEqual(
+      {
+        id: items[0].id,
+        label: items[0].label,
+        cwd: items[0].cwd,
+        updatedAt: items[0].updatedAt,
+        updatedAtSource: items[0].updatedAtSource,
+        matchedCwd: items[0].matchedCwd,
+      },
+      {
+        id: 'kimi-session-1',
+        label: '继续 Kimi 项目',
+        cwd: '/Users/bravf/code/promptx',
+        updatedAt: stateTime.toISOString(),
+        updatedAtSource: 'explicit',
+        matchedCwd: true,
+      }
+    )
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true })
+  }
+})

package/apps/server/src/agents/index.js

@@ -7,6 +7,7 @@ import {
 import { codexRunner } from './codexRunner.js'
 import { claudeCodeRunner } from './claudeCodeRunner.js'
 import { openCodeRunner } from './openCodeRunner.js'
+import { kimiCodeRunner } from './kimiCodeRunner.js'
 
 const SHELL_ENGINE = 'shell'
 const shellRunner = {
@@ -18,6 +19,7 @@ const runnerRegistry = new Map([
   [codexRunner.engine, codexRunner],
   [claudeCodeRunner.engine, claudeCodeRunner],
   [openCodeRunner.engine, openCodeRunner],
+  [kimiCodeRunner.engine, kimiCodeRunner],
   [shellRunner.engine, shellRunner],
 ])