@lih-x-x/kmr 1.0.3 → 1.0.5

package/dist/index.js

@@ -24,6 +24,11 @@ function createEventDispatcher(onMessage) {
         return;
       }
       const messageId = message.message_id;
+      const senderType = data.sender?.sender_type;
+      if (senderType === "app") {
+        console.log(`[recv] \u5FFD\u7565\u673A\u5668\u4EBA\u81EA\u8EAB\u6D88\u606F: ${messageId}`);
+        return;
+      }
       if (processedMessages.has(messageId)) {
         console.log(`[dedup] \u8DF3\u8FC7\u91CD\u590D\u6D88\u606F: ${messageId}`);
         return;
@@ -398,6 +403,36 @@ var RANK_RESULTS_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u641C\u7D22\u6392\u5E8F\u52A
 
 \u7528\u6237\u67E5\u8BE2\uFF1A`;
 
+// src/utils/claudeEnv.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var cachedEnv = null;
+function getClaudeEnv() {
+  if (cachedEnv) return cachedEnv;
+  const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+  let settingsEnv = {};
+  try {
+    const content = fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    if (settings.env && typeof settings.env === "object") {
+      settingsEnv = settings.env;
+    }
+  } catch {
+  }
+  cachedEnv = { ...settingsEnv };
+  for (const key of Object.keys(settingsEnv)) {
+    if (process.env[key]) {
+      cachedEnv[key] = process.env[key];
+    }
+  }
+  return cachedEnv;
+}
+function getExecEnv() {
+  const claudeEnv = getClaudeEnv();
+  return { ...process.env, ...claudeEnv };
+}
+
 // src/agent/claudeCode.ts
 var execFileAsync = promisify(execFile);
 var ClaudeCodeProvider = class {
@@ -448,7 +483,8 @@ ${prompt}
     try {
       const { stdout } = await execFileAsync("acpx", ["--allowed-tools", "", "claude", "exec", prompt], {
         timeout: this.timeout,
-        maxBuffer: 1024 * 1024
+        maxBuffer: 1024 * 1024,
+        env: getExecEnv()
       });
       return this.extractJson(stdout);
     } catch (err) {
@@ -489,31 +525,31 @@ ${prompt}
 };
 
 // src/storage/jsonStore.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 var JsonStore = class {
   constructor(dataDir) {
     this.dataDir = dataDir;
-    fs.mkdirSync(dataDir, { recursive: true });
+    fs2.mkdirSync(dataDir, { recursive: true });
   }
   dataDir;
   async save(record) {
     const date = record.summary.date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const fileName = `${date}_${record.id}.json`;
-    const filePath = path.join(this.dataDir, fileName);
-    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
+    const filePath = path2.join(this.dataDir, fileName);
+    fs2.writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
     return filePath;
   }
   async load(id) {
     const files = this.getFiles();
     const target = files.find((f) => f.includes(id));
     if (!target) return null;
-    const raw = fs.readFileSync(target, "utf-8");
+    const raw = fs2.readFileSync(target, "utf-8");
     return JSON.parse(raw);
   }
   async list() {
     const files = this.getFiles();
-    return files.map((f) => JSON.parse(fs.readFileSync(f, "utf-8")));
+    return files.map((f) => JSON.parse(fs2.readFileSync(f, "utf-8")));
   }
   async search(keywords) {
     const all = await this.list();
@@ -526,25 +562,25 @@ var JsonStore = class {
     const files = this.getFiles();
     const target = files.find((f) => f.includes(id));
     if (!target) return false;
-    fs.unlinkSync(target);
+    fs2.unlinkSync(target);
     return true;
   }
   getFiles() {
-    if (!fs.existsSync(this.dataDir)) return [];
-    return fs.readdirSync(this.dataDir).filter((f) => f.endsWith(".json")).map((f) => path.join(this.dataDir, f));
+    if (!fs2.existsSync(this.dataDir)) return [];
+    return fs2.readdirSync(this.dataDir).filter((f) => f.endsWith(".json")).map((f) => path2.join(this.dataDir, f));
   }
 };
 
 // src/query/finder.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 async function grepMeetings(dataDir, keywords) {
-  if (!fs2.existsSync(dataDir)) return [];
-  const files = fs2.readdirSync(dataDir).filter((f) => f.endsWith(".json"));
+  if (!fs3.existsSync(dataDir)) return [];
+  const files = fs3.readdirSync(dataDir).filter((f) => f.endsWith(".json"));
   const matches = [];
   for (const file of files) {
-    const filePath = path2.join(dataDir, file);
-    const raw = fs2.readFileSync(filePath, "utf-8");
+    const filePath = path3.join(dataDir, file);
+    const raw = fs3.readFileSync(filePath, "utf-8");
     const hasMatch = keywords.some((kw) => raw.includes(kw));
     if (hasMatch) {
       matches.push(JSON.parse(raw));
@@ -572,11 +608,11 @@ var QueryHandler = class {
 
 // src/web/server.ts
 import http from "http";
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
-var PUBLIC_DIR = path3.join(__dirname, "public");
+var __dirname = path4.dirname(fileURLToPath(import.meta.url));
+var PUBLIC_DIR = path4.join(__dirname, "public");
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -586,30 +622,30 @@ var MIME_TYPES = {
   ".svg": "image/svg+xml"
 };
 function serveStatic(res, urlPath) {
-  const safePath = path3.normalize(urlPath).replace(/^(\.\.[/\\])+/, "");
-  let filePath = path3.join(PUBLIC_DIR, safePath === "/" ? "index.html" : safePath);
-  if (!fs3.existsSync(filePath) || fs3.statSync(filePath).isDirectory()) {
-    filePath = path3.join(PUBLIC_DIR, "index.html");
+  const safePath = path4.normalize(urlPath).replace(/^(\.\.[/\\])+/, "");
+  let filePath = path4.join(PUBLIC_DIR, safePath === "/" ? "index.html" : safePath);
+  if (!fs4.existsSync(filePath) || fs4.statSync(filePath).isDirectory()) {
+    filePath = path4.join(PUBLIC_DIR, "index.html");
   }
-  const ext = path3.extname(filePath);
+  const ext = path4.extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
-  const content = fs3.readFileSync(filePath);
+  const content = fs4.readFileSync(filePath);
   res.writeHead(200, { "Content-Type": contentType });
   res.end(content);
 }
 function listSessions(kmrDir) {
-  const sessionsDir = path3.join(kmrDir, "sessions");
-  if (!fs3.existsSync(sessionsDir)) return [];
-  return fs3.readdirSync(sessionsDir).filter((d) => {
-    const full = path3.join(sessionsDir, d);
-    return fs3.statSync(full).isDirectory();
+  const sessionsDir = path4.join(kmrDir, "sessions");
+  if (!fs4.existsSync(sessionsDir)) return [];
+  return fs4.readdirSync(sessionsDir).filter((d) => {
+    const full = path4.join(sessionsDir, d);
+    return fs4.statSync(full).isDirectory();
   }).map((userId) => {
-    const summaryPath = path3.join(sessionsDir, userId, "summary.md");
+    const summaryPath = path4.join(sessionsDir, userId, "summary.md");
     let summaryPreview = "";
     let messageCount = 0;
     let lastActivity = "";
-    if (fs3.existsSync(summaryPath)) {
-      const content = fs3.readFileSync(summaryPath, "utf-8");
+    if (fs4.existsSync(summaryPath)) {
+      const content = fs4.readFileSync(summaryPath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim().length > 0);
       messageCount = lines.length;
       for (let i = lines.length - 1; i >= 0; i--) {
@@ -621,26 +657,26 @@ function listSessions(kmrDir) {
       const lastLine = lines[lines.length - 1] || "";
       const timeMatch = lastLine.match(/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\]/);
       if (timeMatch) lastActivity = timeMatch[1];
-      const stat = fs3.statSync(summaryPath);
+      const stat = fs4.statSync(summaryPath);
       if (!lastActivity) lastActivity = stat.mtime.toISOString().replace("T", " ").slice(0, 19);
     } else {
-      const userDir = path3.join(sessionsDir, userId);
-      const stat = fs3.statSync(userDir);
+      const userDir = path4.join(sessionsDir, userId);
+      const stat = fs4.statSync(userDir);
       lastActivity = stat.mtime.toISOString().replace("T", " ").slice(0, 19);
     }
     return { userId, summaryPreview, messageCount, lastActivity };
   }).sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
 }
 function deleteSession(kmrDir, userId) {
-  const sessionDir = path3.join(kmrDir, "sessions", userId);
-  if (!fs3.existsSync(sessionDir)) return false;
-  fs3.rmSync(sessionDir, { recursive: true, force: true });
+  const sessionDir = path4.join(kmrDir, "sessions", userId);
+  if (!fs4.existsSync(sessionDir)) return false;
+  fs4.rmSync(sessionDir, { recursive: true, force: true });
   return true;
 }
 function getSessionDetail(kmrDir, userId) {
-  const summaryPath = path3.join(kmrDir, "sessions", userId, "summary.md");
-  if (!fs3.existsSync(summaryPath)) return null;
-  return fs3.readFileSync(summaryPath, "utf-8");
+  const summaryPath = path4.join(kmrDir, "sessions", userId, "summary.md");
+  if (!fs4.existsSync(summaryPath)) return null;
+  return fs4.readFileSync(summaryPath, "utf-8");
 }
 function startWebServer(store, kmrDir, port = 3e3) {
   return new Promise((resolve, reject) => {
@@ -710,8 +746,8 @@ async function handleApi(req, res, url, store, kmrDir) {
       return;
     }
     if (pathname === "/api/config" && method === "GET") {
-      const configPath = path3.join(kmrDir, "config.json");
-      const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      const configPath = path4.join(kmrDir, "config.json");
+      const config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
       jsonResponse(res, 200, { ok: true, data: config });
       return;
     }
@@ -724,8 +760,8 @@ async function handleApi(req, res, url, store, kmrDir) {
         jsonResponse(res, 400, { ok: false, error: "\u65E0\u6548\u7684 JSON \u683C\u5F0F" });
         return;
       }
-      const configPath = path3.join(kmrDir, "config.json");
-      fs3.writeFileSync(configPath, JSON.stringify(parsed, null, 2), "utf-8");
+      const configPath = path4.join(kmrDir, "config.json");
+      fs4.writeFileSync(configPath, JSON.stringify(parsed, null, 2), "utf-8");
       jsonResponse(res, 200, { ok: true, data: parsed });
       return;
     }
@@ -779,8 +815,8 @@ function openBrowser(url) {
 // src/session/manager.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify2 } from "util";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/session/skill.ts
 var SESSION_SKILL = `\u4F60\u662F KMR\uFF08Key Meetings Record\uFF09\u7684\u667A\u80FD\u52A9\u624B\u3002
@@ -808,8 +844,8 @@ var execFileAsync2 = promisify2(execFile3);
 var SessionManager = class {
   constructor(kmrDir, timeout = 6e4) {
     this.timeout = timeout;
-    this.sessionDir = path4.join(kmrDir, "sessions");
-    fs4.mkdirSync(this.sessionDir, { recursive: true });
+    this.sessionDir = path5.join(kmrDir, "sessions");
+    fs5.mkdirSync(this.sessionDir, { recursive: true });
   }
   timeout;
   activeSessions = /* @__PURE__ */ new Map();
@@ -828,15 +864,16 @@ var SessionManager = class {
       return existing.name;
     }
     const sessionName = `kmr-${userId}`;
-    const userDir = path4.join(this.sessionDir, userId);
-    fs4.mkdirSync(userDir, { recursive: true });
-    const skillPath = path4.join(userDir, "skill.md");
-    fs4.writeFileSync(skillPath, SESSION_SKILL, "utf-8");
+    const userDir = path5.join(this.sessionDir, userId);
+    fs5.mkdirSync(userDir, { recursive: true });
+    const skillPath = path5.join(userDir, "skill.md");
+    fs5.writeFileSync(skillPath, SESSION_SKILL, "utf-8");
     console.log(`[session] \u521B\u5EFA\u65B0 session: ${sessionName}`);
     try {
       await execFileAsync2("acpx", ["claude", "sessions", "ensure", "--name", sessionName], {
         timeout: this.timeout,
-        maxBuffer: 1024 * 1024
+        maxBuffer: 1024 * 1024,
+        env: getExecEnv()
       });
     } catch (err) {
       console.error(`[session] \u521B\u5EFA session \u5931\u8D25:`, err.message);
@@ -847,7 +884,7 @@ var SessionManager = class {
       await execFileAsync2(
         "acpx",
         ["--approve-all", "claude", "-s", sessionName, SESSION_SKILL],
-        { timeout: this.timeout, maxBuffer: 1024 * 1024 }
+        { timeout: this.timeout, maxBuffer: 1024 * 1024, env: getExecEnv() }
       );
     } catch (err) {
       console.error(`[session] \u89D2\u8272\u8BBE\u5B9A\u5931\u8D25:`, err.message);
@@ -863,7 +900,7 @@ var SessionManager = class {
       const { stdout } = await execFileAsync2(
         "acpx",
         ["--approve-all", "claude", "-s", sessionName, text],
-        { timeout: this.timeout, maxBuffer: 1024 * 1024 }
+        { timeout: this.timeout, maxBuffer: 1024 * 1024, env: getExecEnv() }
       );
       return this.extractReply(stdout);
     } catch (err) {
@@ -882,21 +919,22 @@ var SessionManager = class {
     return filtered || output.trim();
   }
   async appendSummary(userId, userText, aiReply) {
-    const userDir = path4.join(this.sessionDir, userId);
-    const summaryPath = path4.join(userDir, "summary.md");
+    const userDir = path5.join(this.sessionDir, userId);
+    const summaryPath = path5.join(userDir, "summary.md");
     const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
     const entry = `
 [${now}] \u7528\u6237: ${userText}
 [${now}] AI: ${aiReply}
 `;
-    fs4.appendFileSync(summaryPath, entry, "utf-8");
+    fs5.appendFileSync(summaryPath, entry, "utf-8");
   }
   async closeSession(userId) {
     const info = this.activeSessions.get(userId);
     if (!info) return;
     try {
       await execFileAsync2("acpx", ["claude", "sessions", "close", info.name], {
-        timeout: 1e4
+        timeout: 1e4,
+        env: getExecEnv()
       });
       console.log(`[session] \u5DF2\u5173\u95ED session: ${info.name}`);
     } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lih-x-x/kmr",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "type": "module",
   "main": "dist/index.js",
   "bin": {