@coclaw/openclaw-coclaw 0.8.2 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coclaw/openclaw-coclaw",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "type": "module",
   "license": "Apache-2.0",
   "description": "OpenClaw CoClaw channel plugin for remote chat",

package/src/config.js

@@ -29,19 +29,24 @@ function toRecord(value) {
 }
 
 async function readJson(filePath) {
+	let raw;
 	try {
-		const raw = await fs.readFile(filePath, 'utf8');
-		if (!String(raw).trim()) {
-			return {};
-		}
-		return JSON.parse(raw);
+		raw = await fs.readFile(filePath, 'utf8');
 	}
 	catch (err) {
-		if (err?.code === 'ENOENT') {
-			return {};
-		}
+		if (err?.code === 'ENOENT') return {};
+		/* c8 ignore next 2 */
 		throw err;
 	}
+	if (!String(raw).trim()) return {};
+	try {
+		return JSON.parse(raw);
+	}
+	catch {
+		// 文件损坏，删除后当空文件处理
+		await fs.unlink(filePath).catch(() => {});
+		return {};
+	}
 }
 
 const bindingsMutex = createMutex();

package/src/file-manager/handler.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import nodePath from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { randomUUID, randomBytes } from 'node:crypto';
 
 // --- 常量 ---
 
@@ -93,6 +93,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 	const _readdir = deps.readdir ?? fsp.readdir;
 	const _unlink = deps.unlink ?? fsp.unlink;
 	const _rmdir = deps.rmdir ?? fsp.rmdir;
+	const _rm = deps.rm ?? fsp.rm;
 	const _stat = deps.stat ?? fsp.stat;
 	const _mkdir = deps.mkdir ?? fsp.mkdir;
 	const _rename = deps.rename ?? fsp.rename;
@@ -102,22 +103,28 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 
 	const pathDeps = { lstat: _lstat, realpath: _realpath };
 
-	// --- RPC 处理（rpc DC 上的 coclaw.file.list / coclaw.file.delete） ---
+	// --- RPC 处理（rpc DC 上的 coclaw.files.* 方法） ---
 
 	/**
-	 * 处理 rpc DC 上的 coclaw.file.* 请求
+	 * 处理 rpc DC 上的 coclaw.files.* 请求
 	 * @param {object} payload - { id, method, params }
 	 * @param {function} sendFn - (responseObj) => void
 	 */
 	async function handleRpcRequest(payload, sendFn) {
 		const { id, method, params } = payload;
 		try {
-			if (method === 'coclaw.file.list') {
+			if (method === 'coclaw.files.list') {
 				const result = await listFiles(params);
 				sendFn({ type: 'res', id, ok: true, payload: result });
-			} else if (method === 'coclaw.file.delete') {
+			} else if (method === 'coclaw.files.delete') {
 				const result = await deleteFile(params);
 				sendFn({ type: 'res', id, ok: true, payload: result });
+			} else if (method === 'coclaw.files.mkdir') {
+				const result = await mkdirOp(params);
+				sendFn({ type: 'res', id, ok: true, payload: result });
+			} else if (method === 'coclaw.files.create') {
+				const result = await createFile(params);
+				sendFn({ type: 'res', id, ok: true, payload: result });
 			} else {
 				sendFn({
 					type: 'res', id, ok: false,
@@ -207,15 +214,19 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 			throw e;
 		}
 		if (stat.isDirectory()) {
-			try {
-				await _rmdir(resolved);
-			} catch (e) {
-				if (e.code === 'ENOTEMPTY') {
-					const err = new Error(`Directory not empty: ${userPath}`);
-					err.code = 'NOT_EMPTY';
-					throw err;
+			if (params?.force) {
+				await _rm(resolved, { recursive: true, force: true });
+			} else {
+				try {
+					await _rmdir(resolved);
+				} catch (e) {
+					if (e.code === 'ENOTEMPTY') {
+						const err = new Error(`Directory not empty: ${userPath}`);
+						err.code = 'NOT_EMPTY';
+						throw err;
+					}
+					throw e;
 				}
-				throw e;
 			}
 		} else {
 			await _unlink(resolved);
@@ -223,6 +234,79 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		return {};
 	}
 
+	async function mkdirOp(params) {
+		const agentId = params?.agentId?.trim?.() || 'main';
+		const userPath = params?.path;
+		if (!userPath) {
+			const err = new Error('path is required');
+			err.code = 'PATH_DENIED';
+			throw err;
+		}
+		const workspaceDir = await resolveWorkspace(agentId);
+		const resolved = await validatePath(workspaceDir, userPath, pathDeps);
+		await _mkdir(resolved, { recursive: true });
+		return {};
+	}
+
+	async function createFile(params) {
+		const agentId = params?.agentId?.trim?.() || 'main';
+		const userPath = params?.path;
+		if (!userPath) {
+			const err = new Error('path is required');
+			err.code = 'PATH_DENIED';
+			throw err;
+		}
+		const workspaceDir = await resolveWorkspace(agentId);
+		const resolved = await validatePath(workspaceDir, userPath, pathDeps);
+
+		// 检查文件是否已存在
+		try {
+			await _lstat(resolved);
+			// 没抛异常说明存在
+			const err = new Error(`File already exists: ${userPath}`);
+			err.code = 'ALREADY_EXISTS';
+			throw err;
+		} catch (e) {
+			if (e.code === 'ALREADY_EXISTS') throw e;
+			if (e.code !== 'ENOENT') throw e;
+			// ENOENT — 不存在，继续创建
+		}
+
+		// 确保父目录存在
+		await _mkdir(nodePath.dirname(resolved), { recursive: true });
+		await (deps.writeFile ?? fsp.writeFile)(resolved, '');
+		return {};
+	}
+
+	/**
+	 * 生成唯一文件名：<name>-<4hex>.<ext>，碰撞时重试
+	 * @param {string} dir - 目标目录绝对路径
+	 * @param {string} fileName - 原始文件名
+	 * @returns {Promise<string>} 唯一文件名（仅文件名，非完整路径）
+	 */
+	async function generateUniqueName(dir, fileName) {
+		const ext = nodePath.extname(fileName);
+		const base = nodePath.basename(fileName, ext);
+		const maxAttempts = 20;
+		for (let i = 0; i < maxAttempts; i++) {
+			const hex = randomBytes(2).toString('hex');
+			const candidate = `${base}-${hex}${ext}`;
+			try {
+				await _lstat(nodePath.join(dir, candidate));
+				// 存在 → 碰撞，重试
+			} catch (e) {
+				if (e.code === 'ENOENT') return candidate;
+				/* c8 ignore next -- lstat 非 ENOENT 属罕见 IO 异常 */
+				throw e;
+			} /* c8 ignore next */
+		}
+		/* c8 ignore start -- 20 次均碰撞几乎不可能 */
+		const err = new Error(`Cannot generate unique name for: ${fileName}`);
+		err.code = 'WRITE_FAILED';
+		throw err;
+		/* c8 ignore stop */
+	}
+
 	// --- File DataChannel 处理 ---
 
 	/**
@@ -262,15 +346,20 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 				return;
 			}
 
-			if (req.method === 'read') {
-				/* c8 ignore next 3 -- handleRead 内部已完整处理异常，此 catch 纯防御 */
-				handleRead(dc, req).catch((err) => {
-					log.warn?.(`[coclaw/file] read error: ${err.message}`);
+			if (req.method === 'GET') {
+				/* c8 ignore next 3 -- handleGet 内部已完整处理异常，此 catch 纯防御 */
+				handleGet(dc, req).catch((err) => {
+					log.warn?.(`[coclaw/file] GET error: ${err.message}`);
+				});
+			} else if (req.method === 'PUT') {
+				/* c8 ignore next 3 -- handlePut 内部已完整处理异常，此 catch 纯防御 */
+				handlePut(dc, req).catch((err) => {
+					log.warn?.(`[coclaw/file] PUT error: ${err.message}`);
 				});
-			} else if (req.method === 'write') {
-				/* c8 ignore next 3 -- handleWrite 内部已完整处理异常，此 catch 纯防御 */
-				handleWrite(dc, req).catch((err) => {
-					log.warn?.(`[coclaw/file] write error: ${err.message}`);
+			} else if (req.method === 'POST') {
+				/* c8 ignore next 3 -- handlePost 内部已完整处理异常，此 catch 纯防御 */
+				handlePost(dc, req).catch((err) => {
+					log.warn?.(`[coclaw/file] POST error: ${err.message}`);
 				});
 			} else {
 				sendError(dc, 'UNKNOWN_METHOD', `Unknown method: ${req.method}`);
@@ -278,7 +367,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		};
 	}
 
-	async function handleRead(dc, req) {
+	async function handleGet(dc, req) {
 		let workspaceDir, resolved;
 		try {
 			const agentId = req.agentId?.trim?.() || 'main'; /* c8 ignore next -- ?./?? fallback */
@@ -367,7 +456,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		});
 	}
 
-	async function handleWrite(dc, req) {
+	async function handlePut(dc, req) {
 		let workspaceDir, resolved;
 		try {
 			const agentId = req.agentId?.trim?.() || 'main';
@@ -377,7 +466,59 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 			sendError(dc, err.code ?? 'INTERNAL_ERROR', err.message);
 			return;
 		}
+		await receiveUpload(dc, req, resolved);
+	}
+
+	async function handlePost(dc, req) {
+		let workspaceDir, dirResolved;
+		try {
+			const agentId = req.agentId?.trim?.() || 'main';
+			workspaceDir = await resolveWorkspace(agentId);
+			dirResolved = await validatePath(workspaceDir, req.path || '.', pathDeps);
+		} catch (err) {
+			sendError(dc, err.code ?? 'INTERNAL_ERROR', err.message);
+			return;
+		}
 
+		const fileName = req.fileName;
+		if (!fileName || typeof fileName !== 'string') {
+			sendError(dc, 'INVALID_INPUT', 'fileName is required for POST');
+			return;
+		}
+
+		// 确保集合目录存在
+		try {
+			await _mkdir(dirResolved, { recursive: true });
+		} catch (err) {
+			sendError(dc, 'WRITE_FAILED', `Cannot create directory: ${err.message}`);
+			return;
+		}
+
+		// 生成唯一文件名
+		let uniqueName;
+		try {
+			uniqueName = await generateUniqueName(dirResolved, fileName);
+		/* c8 ignore start -- generateUniqueName 内部已处理，此为防御 */
+		} catch (err) {
+			sendError(dc, err.code ?? 'WRITE_FAILED', err.message);
+			return;
+		}
+		/* c8 ignore stop */
+
+		const resolved = nodePath.join(dirResolved, uniqueName);
+		// 计算相对于 workspace 的路径，作为响应中的 path
+		const relativePath = nodePath.relative(workspaceDir, resolved);
+		await receiveUpload(dc, req, resolved, relativePath);
+	}
+
+	/**
+	 * 共享上传接收逻辑（PUT/POST 复用）
+	 * @param {object} dc - DataChannel
+	 * @param {object} req - 请求对象（含 size）
+	 * @param {string} resolved - 目标文件绝对路径
+	 * @param {string} [relativePath] - POST 时附带的相对路径（响应中返回）
+	 */
+	async function receiveUpload(dc, req, resolved, relativePath) {
 		const declaredSize = req.size;
 		if (!Number.isFinite(declaredSize) || declaredSize < 0) {
 			sendError(dc, 'INVALID_INPUT', 'size must be a non-negative number');
@@ -388,7 +529,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 			return;
 		}
 
-		// 确保目标目录存在
+		// 确保目标目录存在（PUT 场景需要；POST 已在上层创建，幂等无害）
 		const targetDir = nodePath.dirname(resolved);
 		try {
 			await _mkdir(targetDir, { recursive: true });
@@ -460,8 +601,10 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 							try { dc.close(); } catch { /* ignore */ }
 							return;
 						}
+						const result = { ok: true, bytes: receivedBytes };
+						if (relativePath) result.path = relativePath;
 						try {
-							dc.send(JSON.stringify({ ok: true, bytes: receivedBytes }));
+							dc.send(JSON.stringify(result));
 						/* c8 ignore next */
 						} catch { /* ignore */ }
 						/* c8 ignore next */
@@ -580,8 +723,12 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		// 暴露内部方法便于测试
 		__listFiles: listFiles,
 		__deleteFile: deleteFile,
-		__handleRead: handleRead,
-		__handleWrite: handleWrite,
+		__mkdirOp: mkdirOp,
+		__createFile: createFile,
+		__handleGet: handleGet,
+		__handlePut: handlePut,
+		__handlePost: handlePost,
+		__generateUniqueName: generateUniqueName,
 		__cleanupTmpFilesInDir: cleanupTmpFilesInDir,
 	};
 }

package/src/webrtc-peer.js

@@ -10,7 +10,7 @@ export class WebRtcPeer {
 	 * @param {object} opts
 	 * @param {function} opts.onSend - 将信令消息交给 RealtimeBridge 发送
 	 * @param {function} [opts.onRequest] - DataChannel 收到 req 消息时的回调 (payload, connId) => void
-	 * @param {function} [opts.onFileRpc] - rpc DC 上 coclaw.file.* 请求的回调 (payload, sendFn, connId) => void
+	 * @param {function} [opts.onFileRpc] - rpc DC 上 coclaw.files.* 请求的回调 (payload, sendFn, connId) => void
 	 * @param {function} [opts.onFileChannel] - file:<transferId> DataChannel 的回调 (dc, connId) => void
 	 * @param {object} [opts.logger] - pino 风格 logger
 	 * @param {function} [opts.PeerConnection] - 可替换的构造函数（测试用）
@@ -218,8 +218,8 @@ export class WebRtcPeer {
 		const reassembler = createReassembler((jsonStr) => {
 			const payload = JSON.parse(jsonStr);
 			if (payload.type === 'req') {
-				// coclaw.file.* 方法本地处理，不转发 gateway
-				if (payload.method?.startsWith('coclaw.file.') && this.__onFileRpc) {
+				// coclaw.files.* 方法本地处理，不转发 gateway
+				if (payload.method?.startsWith('coclaw.files.') && this.__onFileRpc) {
 					const session = this.__sessions.get(connId);
 					const sendFn = (response) => {
 						try {