hyperclaw 5.4.0 → 5.4.2

package/dist/src-DFo8lVfV.js

@@ -0,0 +1,300 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const path = require_chunk.__toESM(require("path"));
+const crypto = require_chunk.__toESM(require("crypto"));
+
+//#region packages/acp/src/server.ts
+var ACPServer = class {
+	sessions = /* @__PURE__ */ new Map();
+	initialized = false;
+	sendUpdate;
+	cancelCurrent = null;
+	constructor(sendUpdate) {
+		this.sendUpdate = sendUpdate;
+	}
+	sendResponse(id, result, error) {
+		const msg = {
+			jsonrpc: "2.0",
+			id,
+			...error ? { error } : { result: result ?? null }
+		};
+		this.write(JSON.stringify(msg));
+	}
+	write(raw) {
+		const buf = Buffer.from(raw, "utf8");
+		process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`, "utf8");
+		process.stdout.write(buf, "utf8");
+	}
+	async handleInitialize(params) {
+		this.initialized = true;
+		return {
+			protocolVersion: params.protocolVersion ?? 1,
+			agentCapabilities: {
+				loadSession: true,
+				promptCapabilities: {
+					image: true,
+					audio: false,
+					embeddedContext: true
+				},
+				mcp: {
+					http: true,
+					sse: false
+				}
+			},
+			agentInfo: {
+				name: "hyperclaw",
+				title: "HyperClaw",
+				version: "5.4.0"
+			},
+			authMethods: []
+		};
+	}
+	async handleSessionNew(params) {
+		const id = `sess_${crypto.default.randomBytes(8).toString("hex")}`;
+		const cwd = params.cwd ? path.default.resolve(params.cwd) : process.cwd();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		this.sessions.set(id, {
+			id,
+			cwd,
+			transcript: [],
+			created: now,
+			lastActive: now
+		});
+		return { sessionId: id };
+	}
+	async handleSessionLoad(params) {
+		const sess = this.sessions.get(params.sessionId);
+		if (!sess) {
+			const { ACPThreadManager } = await Promise.resolve().then(() => require("./src-9GyYED0T.js"));
+			const mgr = new ACPThreadManager();
+			const thread = await mgr.get(params.sessionId.replace(/^sess_/, ""));
+			if (!thread) throw new Error(`Session not found: ${params.sessionId}`);
+			const cwd = params.cwd ? path.default.resolve(params.cwd) : thread.workspace || process.cwd();
+			const transcript = thread.messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
+				role: m.role,
+				content: m.content
+			}));
+			const sess2 = {
+				id: params.sessionId,
+				cwd,
+				transcript,
+				created: thread.createdAt,
+				lastActive: thread.lastActiveAt
+			};
+			this.sessions.set(params.sessionId, sess2);
+			for (const t of transcript) this.sendUpdate({
+				sessionId: params.sessionId,
+				update: {
+					sessionUpdate: t.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+					content: {
+						type: "text",
+						text: t.content
+					}
+				}
+			});
+			return;
+		}
+		for (const t of sess.transcript) this.sendUpdate({
+			sessionId: params.sessionId,
+			update: {
+				sessionUpdate: t.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+				content: {
+					type: "text",
+					text: t.content
+				}
+			}
+		});
+	}
+	async handleSessionPrompt(params) {
+		const sess = this.sessions.get(params.sessionId);
+		if (!sess) throw new Error(`Session not found: ${params.sessionId}`);
+		const userText = params.prompt.map((p) => p.type === "text" ? p.text : p.type === "resource" ? p.resource.text ?? "" : "").filter(Boolean).join("\n");
+		if (!userText.trim()) throw new Error("Empty prompt");
+		sess.transcript.push({
+			role: "user",
+			content: userText
+		});
+		sess.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+		const abortController = new AbortController();
+		this.cancelCurrent = () => abortController.abort();
+		let stopReason = "end_turn";
+		try {
+			const { runAgentEngine } = await Promise.resolve().then(() => require("./src-9GyYED0T.js"));
+			const toolCallIds = /* @__PURE__ */ new Map();
+			const result = await runAgentEngine(userText, {
+				sessionId: params.sessionId,
+				source: "acp",
+				elevated: true,
+				transcript: sess.transcript.slice(0, -1),
+				workspace: sess.cwd,
+				modelOverride: void 0,
+				getTranscript: async () => sess.transcript.slice(0, -1),
+				appendTranscript: (key, role, content) => {
+					sess.transcript.push({
+						role,
+						content
+					});
+					sess.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+				},
+				onToken: (token) => {
+					this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "agent_message_chunk",
+							content: {
+								type: "text",
+								text: token
+							}
+						}
+					});
+				},
+				onThinking: (thought) => {
+					this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "thought_chunk",
+							content: {
+								type: "text",
+								text: thought
+							}
+						}
+					});
+				},
+				onToolCall: (name, input) => {
+					const id = `call_${crypto.default.randomBytes(4).toString("hex")}`;
+					toolCallIds.set(name, id);
+					this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "tool_call",
+							toolCallId: id,
+							title: name,
+							kind: "other",
+							status: "pending"
+						}
+					});
+				},
+				onToolResult: (name) => {
+					const id = toolCallIds.get(name);
+					if (id) this.sendUpdate({
+						sessionId: params.sessionId,
+						update: {
+							sessionUpdate: "tool_call_update",
+							toolCallId: id,
+							status: "completed"
+						}
+					});
+				}
+			});
+			if (result.error === "cancelled") stopReason = "cancelled";
+			sess.transcript.push({
+				role: "assistant",
+				content: result.text || ""
+			});
+			sess.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+		} catch (e) {
+			const err = e;
+			if (err?.name === "AbortError" || err?.message?.includes("abort")) stopReason = "cancelled";
+			else throw e;
+		} finally {
+			this.cancelCurrent = null;
+		}
+		return { stopReason };
+	}
+	handleSessionCancel(params) {
+		if (this.cancelCurrent) this.cancelCurrent();
+	}
+	getSession(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	async dispatch(req) {
+		const { id, method, params = {} } = req;
+		if (!this.initialized && method !== "initialize") {
+			this.sendResponse(id, void 0, {
+				code: -32002,
+				message: "Not initialized"
+			});
+			return;
+		}
+		try {
+			let result;
+			switch (method) {
+				case "initialize":
+					result = await this.handleInitialize(params);
+					break;
+				case "session/new":
+					result = await this.handleSessionNew(params);
+					break;
+				case "session/load":
+					result = await this.handleSessionLoad(params);
+					break;
+				case "session/prompt":
+					result = await this.handleSessionPrompt(params);
+					break;
+				case "session/cancel":
+					this.handleSessionCancel(params);
+					result = null;
+					break;
+				default:
+					this.sendResponse(id, void 0, {
+						code: -32601,
+						message: `Method not found: ${method}`
+					});
+					return;
+			}
+			if (method !== "session/cancel") this.sendResponse(id, result);
+		} catch (e) {
+			const err = e;
+			this.sendResponse(id, void 0, {
+				code: -32603,
+				message: err?.message ?? "Internal error",
+				data: { stack: err?.stack }
+			});
+		}
+	}
+};
+/**
+
+* Run ACP server on stdio (Content-Length delimited JSON-RPC).
+
+*/
+async function runACPStdio() {
+	const sendUpdate = (params) => {
+		const msg = {
+			jsonrpc: "2.0",
+			method: "session/update",
+			params
+		};
+		const raw = JSON.stringify(msg);
+		const buf = Buffer.from(raw, "utf8");
+		process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`, "utf8");
+		process.stdout.write(buf, "utf8");
+	};
+	const server = new ACPServer(sendUpdate);
+	let buffer = "";
+	process.stdin.setEncoding("utf8");
+	process.stdin.on("data", (chunk) => {
+		buffer += chunk;
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) break;
+			const headers = buffer.slice(0, headerEnd);
+			const bodyStart = headerEnd + 4;
+			const contentLen = /Content-Length:\s*(\d+)/i.exec(headers)?.[1];
+			if (!contentLen) {
+				buffer = buffer.slice(bodyStart);
+				continue;
+			}
+			const len = parseInt(contentLen, 10);
+			if (buffer.length < bodyStart + len) break;
+			const body = buffer.slice(bodyStart, bodyStart + len);
+			buffer = buffer.slice(bodyStart + len);
+			try {
+				const req = JSON.parse(body);
+				server.dispatch(req);
+			} catch {}
+		}
+	});
+}
+
+//#endregion
+exports.runACPStdio = runACPStdio;