@vibe-lark/larkpal 0.1.72 → 0.1.73

package/dist/main.mjs

@@ -3,7 +3,7 @@ import { n as getLarkRuntime, r as setLarkRuntime, t as larkLogger } from "./lar
 import * as fs from "node:fs";
 import { createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import * as path$2 from "node:path";
-import path, { basename, dirname, extname, join, resolve } from "node:path";
+import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import "dotenv/config";
 import { access, copyFile, lstat, mkdir, open, readFile, readdir, readlink, rename, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
@@ -3679,6 +3679,13 @@ function summarizeString(value) {
 *   DELETE /api/chat/sessions/:id     — 删除会话
 */
 const log$30 = larkLogger("chat/stream");
+var SessionFileUploadError = class extends Error {
+	constructor(message, statusCode = 400) {
+		super(message);
+		this.statusCode = statusCode;
+		this.name = "SessionFileUploadError";
+	}
+};
 const chatRunsBySession = /* @__PURE__ */ new Map();
 const DEFAULT_STALE_RUN_IDLE_MS = 1800 * 1e3;
 /** 统一写 SSE 格式数据到响应流 */
@@ -3771,6 +3778,31 @@ function getRuntimeEventDedupeKey(event) {
 function isRunVisibleToUser(run, params) {
 	return run.tenantKey === params.tenantKey && run.openId === params.openId;
 }
+function getSessionOwner(chatUser) {
+	return {
+		tenantKey: chatUser.tenantKey,
+		openId: chatUser.openId
+	};
+}
+function isSessionOwnedBy$1(session, owner) {
+	return session.tenantKey === owner.tenantKey && session.userId === owner.openId;
+}
+async function getOwnedSession(messageStore, sessionId, chatUser) {
+	return await messageStore.getSessionForOwner(sessionId, getSessionOwner(chatUser));
+}
+function logSessionDecision(params) {
+	log$30.info("[session-audit] chat session access decision", {
+		action: params.action,
+		decision: params.decision,
+		tenantKey: params.chatUser.tenantKey,
+		userId: params.chatUser.userId,
+		openId: params.chatUser.openId,
+		sessionId: params.sessionId,
+		requestId: params.requestId,
+		traceId: params.traceId,
+		reason: params.reason
+	});
+}
 function addRunClient(req, res, run) {
 	run.clients.add(res);
 	req.on("close", () => {
@@ -4009,6 +4041,209 @@ function buildRuntimeEventMessageMetadata(event, runtimeConfig) {
 		finalStatus: event.finalStatus
 	};
 }
+async function handleSessionFileUpload(req, res, messageStore) {
+	const chatUser = res.locals.chatUser;
+	const sessionId = String(req.params.id);
+	const requestId = getGatewayRequestId(req.headers);
+	const traceId = getGatewayTraceId(req.headers, requestId);
+	if (!await getOwnedSession(messageStore, sessionId, chatUser)) {
+		logSessionDecision({
+			action: "attach",
+			decision: "denied",
+			chatUser,
+			sessionId,
+			requestId,
+			traceId,
+			reason: "session_not_owned"
+		});
+		res.status(404).json({ error: "Session not found" });
+		return;
+	}
+	logSessionDecision({
+		action: "attach",
+		decision: "allowed",
+		chatUser,
+		sessionId,
+		requestId,
+		traceId
+	});
+	if (!req.headers["content-type"]?.includes("multipart/form-data")) {
+		res.status(415).json({ error: "Content-Type must be multipart/form-data" });
+		return;
+	}
+	try {
+		const file = await parseSessionFileUpload(req, sessionId);
+		await messageStore.appendMessage({
+			sessionId,
+			role: "tool",
+			content: JSON.stringify({
+				runtimeEventType: "session-file-attached",
+				file
+			}),
+			channel: "web",
+			metadata: {
+				requestId,
+				traceId,
+				runtimeEventType: "session-file-attached",
+				fileName: file.fileName,
+				relativePath: file.relativePath,
+				mimeType: file.mimeType,
+				size: file.size,
+				attachments: [file]
+			}
+		});
+		res.status(201).json({
+			file,
+			files: [file]
+		});
+	} catch (err) {
+		const statusCode = err instanceof SessionFileUploadError ? err.statusCode : 500;
+		const message = err instanceof Error ? err.message : String(err);
+		log$30.warn("[sessions] session file upload failed", {
+			tenantKey: chatUser.tenantKey,
+			userId: chatUser.userId,
+			openId: chatUser.openId,
+			sessionId,
+			requestId,
+			traceId,
+			statusCode,
+			message
+		});
+		res.status(statusCode).json({ error: message });
+	}
+}
+function parseSessionFileUpload(req, sessionId) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const busboy = Busboy({
+			headers: req.headers,
+			limits: {
+				fileSize: getSessionFileUploadMaxBytes(),
+				files: 1
+			}
+		});
+		let metadata;
+		let uploadPromise;
+		let fileSeen = false;
+		let settled = false;
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			rejectPromise(error);
+		};
+		busboy.on("field", (name, value) => {
+			if (name !== "metadata") return;
+			if (!value.trim()) return;
+			try {
+				const parsed = JSON.parse(value);
+				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+					metadata = parsed;
+					return;
+				}
+				fail(new SessionFileUploadError("metadata must be a JSON object"));
+			} catch (err) {
+				fail(new SessionFileUploadError(`metadata is not valid JSON: ${err instanceof Error ? err.message : String(err)}`));
+			}
+		});
+		busboy.on("file", (_name, file, info) => {
+			if (fileSeen) {
+				file.resume();
+				fail(new SessionFileUploadError("Only one file is supported per upload"));
+				return;
+			}
+			fileSeen = true;
+			uploadPromise = writeSessionFile(sessionId, {
+				file,
+				originalName: info.filename || "upload.bin",
+				mimeType: info.mimeType || "application/octet-stream",
+				metadata
+			});
+		});
+		busboy.on("filesLimit", () => fail(new SessionFileUploadError("Only one file is supported per upload")));
+		busboy.on("error", fail);
+		busboy.on("finish", () => {
+			if (settled) return;
+			if (!fileSeen || !uploadPromise) {
+				fail(new SessionFileUploadError("file is required"));
+				return;
+			}
+			uploadPromise.then((file) => {
+				if (settled) return;
+				settled = true;
+				resolvePromise(file);
+			}, fail);
+		});
+		req.pipe(busboy);
+	});
+}
+function writeSessionFile(sessionId, params) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const uploadsDir = resolve(resolveAgentCwd(sessionId), "uploads");
+		const fileName = buildSafeUploadFileName(params.originalName);
+		const destination = resolve(uploadsDir, fileName);
+		const relativePath = `uploads/${fileName}`;
+		const maxBytes = getSessionFileUploadMaxBytes();
+		let size = 0;
+		let settled = false;
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			rejectPromise(error);
+		};
+		if (!isPathInside(uploadsDir, destination)) {
+			fail(new SessionFileUploadError("Invalid upload path"));
+			params.file.resume();
+			return;
+		}
+		mkdir(uploadsDir, { recursive: true }).then(() => {
+			const output = createWriteStream(destination, { flags: "wx" });
+			params.file.on("data", (chunk) => {
+				size += chunk.length;
+				if (size > maxBytes) {
+					output.destroy();
+					fail(new SessionFileUploadError(`File exceeds maximum upload size of ${maxBytes} bytes`, 413));
+				}
+			});
+			params.file.on("limit", () => {
+				output.destroy();
+				fail(new SessionFileUploadError(`File exceeds maximum upload size of ${maxBytes} bytes`, 413));
+			});
+			params.file.on("error", fail);
+			output.on("error", fail);
+			output.on("finish", () => {
+				if (settled) return;
+				settled = true;
+				resolvePromise({
+					sessionId,
+					kind: "session-file",
+					fileName,
+					relativePath,
+					uri: `session-file://${relativePath}`,
+					mimeType: params.mimeType,
+					size,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+					metadata: params.metadata
+				});
+			});
+			params.file.pipe(output);
+		}, fail);
+	});
+}
+function getSessionFileUploadMaxBytes() {
+	const raw = process.env.LARKPAL_SESSION_FILE_MAX_UPLOAD_BYTES || process.env.LARKPAL_ARTIFACT_MAX_UPLOAD_BYTES;
+	if (!raw) return 50 * 1024 * 1024;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 50 * 1024 * 1024;
+}
+function buildSafeUploadFileName(originalName) {
+	const base = basename(originalName).replace(/[\0\r\n\\/]/g, "_");
+	const extension = extname(base).replace(/[^A-Za-z0-9.]/g, "").slice(0, 32);
+	const stem = basename(base, extname(base)).replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+$/, "").slice(0, 80) || "upload";
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}-${stem}${extension}`;
+}
+function isPathInside(parent, child) {
+	const path = relative(parent, child);
+	return path !== "" && !path.startsWith("..") && !isAbsolute(path);
+}
 /**
 * 创建 Chat 流式对话 + 历史查询路由
 *
@@ -4025,7 +4260,8 @@ function createChatRouter(config) {
 	const router = Router();
 	const { processManager, messageStore } = config;
 	router.post("/api/chat/stream", chatAuthMiddleware, async (req, res) => {
-		const { userId, openId, tenantKey } = res.locals.chatUser;
+		const chatUser = res.locals.chatUser;
+		const { userId, openId, tenantKey } = chatUser;
 		const body = req.body;
 		if (!tenantKey || !userId || !openId) {
 			res.status(401).json({ error: "Missing required chat identity: tenantKey, userId, openId" });
@@ -4034,7 +4270,48 @@ function createChatRouter(config) {
 		const requestId = getGatewayRequestId(req.headers);
 		const traceId = getGatewayTraceId(req.headers, requestId);
 		let sessionId = body.session_id;
+		let streamSession = null;
 		const activeRun = sessionId ? getActiveChatRun(sessionId) : void 0;
+		if (sessionId) {
+			streamSession = await messageStore.getSession(sessionId);
+			if (streamSession && !isSessionOwnedBy$1(streamSession, getSessionOwner(chatUser))) {
+				logSessionDecision({
+					action: "stream",
+					decision: "denied",
+					chatUser,
+					sessionId,
+					requestId,
+					traceId,
+					reason: "session_not_owned"
+				});
+				res.status(404).json({ error: "Session not found" });
+				return;
+			}
+			if (!streamSession && activeRun && !isRunVisibleToUser(activeRun, {
+				tenantKey,
+				openId
+			})) {
+				logSessionDecision({
+					action: "stream",
+					decision: "denied",
+					chatUser,
+					sessionId,
+					requestId,
+					traceId,
+					reason: "active_run_not_owned"
+				});
+				res.status(404).json({ error: "Session not found" });
+				return;
+			}
+			if (streamSession || activeRun) logSessionDecision({
+				action: "stream",
+				decision: "allowed",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId
+			});
+		}
 		if (activeRun) {
 			if (!isRunVisibleToUser(activeRun, {
 				tenantKey,
@@ -4057,6 +4334,22 @@ function createChatRouter(config) {
 			res.status(400).json({ error: "prompt is required and must be a string" });
 			return;
 		}
+		if (sessionId && !streamSession) {
+			await messageStore.createSession({
+				id: sessionId,
+				userId: openId,
+				tenantKey,
+				channel: "web"
+			});
+			logSessionDecision({
+				action: "stream",
+				decision: "allowed",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId
+			});
+		}
 		const scenarioId = getScenarioId(body.options?.scenarioId, body.options?.metadata);
 		const attachments = getRunInputValue(body.attachments, body.options?.attachments, body.options?.metadata?.attachments);
 		const sourceArtifacts = getRunInputValue(body.sourceArtifacts, body.source_artifacts, body.options?.sourceArtifacts, body.options?.source_artifacts, body.options?.metadata?.sourceArtifacts, body.options?.metadata?.source_artifacts);
@@ -4077,6 +4370,14 @@ function createChatRouter(config) {
 				tenantKey,
 				channel: "web"
 			})).id;
+			logSessionDecision({
+				action: "create",
+				decision: "allowed",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId
+			});
 			log$30.info("[stream] 自动创建新会话", {
 				userId: openId,
 				sessionId
@@ -4559,6 +4860,29 @@ function createChatRouter(config) {
 	router.post("/api/chat/sessions/:id/cancel-active-run", chatAuthMiddleware, async (req, res) => {
 		const chatUser = res.locals.chatUser;
 		const sessionId = String(req.params.id);
+		const requestId = getGatewayRequestId(req.headers);
+		const traceId = getGatewayTraceId(req.headers, requestId);
+		if (!await getOwnedSession(messageStore, sessionId, chatUser)) {
+			logSessionDecision({
+				action: "cancel",
+				decision: "denied",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId,
+				reason: "session_not_owned"
+			});
+			res.status(404).json({ error: "Session not found" });
+			return;
+		}
+		logSessionDecision({
+			action: "cancel",
+			decision: "allowed",
+			chatUser,
+			sessionId,
+			requestId,
+			traceId
+		});
 		const run = chatRunsBySession.get(sessionId);
 		if (!run) {
 			res.json({
@@ -4596,6 +4920,9 @@ function createChatRouter(config) {
 			});
 		}
 	});
+	router.post("/api/chat/sessions/:id/files", chatAuthMiddleware, async (req, res) => {
+		await handleSessionFileUpload(req, res, messageStore);
+	});
 	router.get("/api/chat/history", chatAuthMiddleware, async (req, res) => {
 		const chatUser = res.locals.chatUser;
 		const sessionId = req.query.session_id;
@@ -4605,6 +4932,8 @@ function createChatRouter(config) {
 		}
 		const cursor = req.query.cursor;
 		const limit = parseInt(req.query.limit, 10) || 50;
+		const requestId = getGatewayRequestId(req.headers);
+		const traceId = getGatewayTraceId(req.headers, requestId);
 		log$30.info("[history] 查询会话历史", {
 			userId: chatUser.userId,
 			sessionId,
@@ -4612,6 +4941,27 @@ function createChatRouter(config) {
 			limit
 		});
 		try {
+			if (!await getOwnedSession(messageStore, sessionId, chatUser)) {
+				logSessionDecision({
+					action: "history",
+					decision: "denied",
+					chatUser,
+					sessionId,
+					requestId,
+					traceId,
+					reason: "session_not_owned"
+				});
+				res.status(404).json({ error: "Session not found" });
+				return;
+			}
+			logSessionDecision({
+				action: "history",
+				decision: "allowed",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId
+			});
 			const result = await messageStore.getMessages(sessionId, {
 				cursor,
 				limit
@@ -4647,6 +4997,29 @@ function createChatRouter(config) {
 			res.status(400).json({ error: "session_id is required" });
 			return;
 		}
+		const requestId = getGatewayRequestId(req.headers);
+		const traceId = getGatewayTraceId(req.headers, requestId);
+		if (!await getOwnedSession(messageStore, sessionId, chatUser)) {
+			logSessionDecision({
+				action: "runs",
+				decision: "denied",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId,
+				reason: "session_not_owned"
+			});
+			res.status(404).json({ error: "Session not found" });
+			return;
+		}
+		logSessionDecision({
+			action: "runs",
+			decision: "allowed",
+			chatUser,
+			sessionId,
+			requestId,
+			traceId
+		});
 		const run = chatRunsBySession.get(sessionId);
 		if (!run || !isRunVisibleToUser(run, {
 			tenantKey: chatUser.tenantKey,
@@ -4673,7 +5046,7 @@ function createChatRouter(config) {
 		const chatUser = res.locals.chatUser;
 		log$30.info("[sessions] 列出用户会话", { userId: chatUser.userId });
 		try {
-			const sessions = await messageStore.listSessions(chatUser.openId);
+			const sessions = await messageStore.listSessions(chatUser.openId, chatUser.tenantKey);
 			res.json({ sessions });
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
@@ -4717,7 +5090,29 @@ function createChatRouter(config) {
 			sessionId
 		});
 		try {
-			await messageStore.deleteSession(sessionId);
+			const requestId = getGatewayRequestId(req.headers);
+			const traceId = getGatewayTraceId(req.headers, requestId);
+			if (!await messageStore.deleteSessionForOwner(sessionId, getSessionOwner(chatUser))) {
+				logSessionDecision({
+					action: "delete",
+					decision: "denied",
+					chatUser,
+					sessionId,
+					requestId,
+					traceId,
+					reason: "session_not_owned"
+				});
+				res.status(404).json({ error: "Session not found" });
+				return;
+			}
+			logSessionDecision({
+				action: "delete",
+				decision: "allowed",
+				chatUser,
+				sessionId,
+				requestId,
+				traceId
+			});
 			chatRunsBySession.delete(sessionId);
 			res.json({ success: true });
 		} catch (err) {
@@ -7935,6 +8330,11 @@ var SessionMessageStore = class {
 	* 创建新会话
 	*/
 	async createSession(session) {
+		const existing = await this.getSession(session.id);
+		if (existing) {
+			if (existing.userId === session.userId && existing.tenantKey === session.tenantKey) return existing;
+			throw new Error(`Session ${session.id} already exists for a different owner`);
+		}
 		const now = Date.now();
 		const fullSession = {
 			...session,
@@ -7946,9 +8346,9 @@ var SessionMessageStore = class {
 			sessionId: fullSession.id,
 			userId: fullSession.userId
 		});
-		const sessions = await this.readUserSessions(fullSession.userId);
+		const sessions = await this.readUserSessions(fullSession.userId, fullSession.tenantKey);
 		sessions.push(fullSession);
-		await this.writeUserSessions(fullSession.userId, sessions);
+		await this.writeUserSessions(fullSession.userId, sessions, fullSession.tenantKey);
 		return fullSession;
 	}
 	/**
@@ -7975,9 +8375,21 @@ var SessionMessageStore = class {
 	/**
 	* 列出指定用户的所有会话
 	*/
-	async listSessions(userId) {
-		log$24.debug("列出用户会话", { userId });
-		return await this.readUserSessions(userId);
+	async listSessions(userId, tenantKey) {
+		log$24.debug("列出用户会话", {
+			userId,
+			tenantKey
+		});
+		const sessions = await this.readUserSessions(userId, tenantKey);
+		if (!tenantKey) return sessions;
+		const ownedLegacySessions = (await this.readUserSessions(userId)).filter((session) => session.userId === userId && session.tenantKey === tenantKey);
+		const seen = new Set(sessions.map((session) => session.id));
+		return [...sessions, ...ownedLegacySessions.filter((session) => !seen.has(session.id))];
+	}
+	async getSessionForOwner(sessionId, owner) {
+		const session = await this.getSession(sessionId);
+		if (!session) return null;
+		return isSessionOwnedBy(session, owner) ? session : null;
 	}
 	/**
 	* 删除指定会话（同时删除消息文件）
@@ -8007,6 +8419,12 @@ var SessionMessageStore = class {
 			throw err;
 		}
 	}
+	async deleteSessionForOwner(sessionId, owner) {
+		const session = await this.getSession(sessionId);
+		if (!session || !isSessionOwnedBy(session, owner)) return false;
+		await this.deleteSession(sessionId);
+		return true;
+	}
 	/**
 	* 追加消息到会话
 	* 同时更新会话的 updatedAt 和 messageCount
@@ -8096,21 +8514,21 @@ var SessionMessageStore = class {
 	/**
 	* 获取用户会话索引文件路径
 	*/
-	getUserSessionFilePath(userId) {
-		return join(this.sessionsDir, `${userId}.json`);
+	getUserSessionFilePath(userId, tenantKey) {
+		return join(this.sessionsDir, `${buildOwnerKey(userId, tenantKey)}.json`);
 	}
 	/**
 	* 读取用户的会话列表
 	*/
-	async readUserSessions(userId) {
-		const filePath = this.getUserSessionFilePath(userId);
+	async readUserSessions(userId, tenantKey) {
+		const filePath = this.getUserSessionFilePath(userId, tenantKey);
 		return await this.readJsonFile(filePath) || [];
 	}
 	/**
 	* 写入用户的会话列表
 	*/
-	async writeUserSessions(userId, sessions) {
-		const filePath = this.getUserSessionFilePath(userId);
+	async writeUserSessions(userId, sessions, tenantKey) {
+		const filePath = this.getUserSessionFilePath(userId, tenantKey);
 		await this.writeJsonFile(filePath, sessions);
 	}
 	/**
@@ -8210,6 +8628,12 @@ var SessionMessageStore = class {
 		} catch {}
 	}
 };
+function isSessionOwnedBy(session, owner) {
+	return session.userId === owner.openId && session.tenantKey === owner.tenantKey;
+}
+function buildOwnerKey(userId, tenantKey) {
+	return (tenantKey ? `${tenantKey}__${userId}` : userId).replace(/[^A-Za-z0-9_.:-]/g, "_");
+}
 //#endregion
 //#region src/messaging/inbound/user-name-cache-store.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-lark/larkpal",
-  "version": "0.1.72",
+  "version": "0.1.73",
   "description": "LarkPal - Lark/Feishu bot service",
   "type": "module",
   "main": "./dist/main.mjs",