hyperclaw 5.4.0 → 5.4.2

package/dist/src-CNAVUFC6.js

@@ -0,0 +1,462 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_browser_tools = require('./browser-tools-BMgBB2fK.js');
+const require_src = require('./src-lltU5gkh.js');
+const require_engine = require('./engine-BTSXJNba.js');
+const require_extraction_tools = require('./extraction-tools-Bh5F0ENP.js');
+const require_inference = require('./inference-DCSz6Sb1.js');
+const require_memory_auto = require('./memory-auto-BVCJeTwd.js');
+const require_orchestrator = require('./orchestrator-C0t11xj7.js');
+const require_pc_access = require('./pc-access-D4g0fjQb.js');
+const require_session_store = require('./session-store-sUpA509O.js');
+const require_sessions_tools = require('./sessions-tools-ClrKqLII.js');
+const require_skill_loader = require('./skill-loader-CM4KWQ7_.js');
+const require_skill_runtime = require('./skill-runtime-D6-rGzX1.js');
+const require_vision_tools = require('./vision-tools-kYb3effk.js');
+const require_website_watch_tools = require('./website-watch-tools-D92dkYZa.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const ora = require_chunk.__toESM(require("ora"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+const crypto = require_chunk.__toESM(require("crypto"));
+const events = require_chunk.__toESM(require("events"));
+
+//#region packages/core/src/agent/pi-rpc.ts
+function createPiRPCHandler(callAgent, getSessions) {
+	return async (req) => {
+		const { id, method, params } = req;
+		try {
+			let result;
+			switch (method) {
+				case "send":
+					result = await handleSend(params, callAgent);
+					break;
+				case "chats.list":
+					result = handleChatsList(getSessions);
+					break;
+				case "ping":
+					result = { pong: Date.now() };
+					break;
+				default: return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32601,
+						message: `Method not found: ${method}`
+					}
+				};
+			}
+			return {
+				jsonrpc: "2.0",
+				id,
+				result
+			};
+		} catch (e) {
+			return {
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code: -32603,
+					message: e.message || "Internal error"
+				}
+			};
+		}
+	};
+}
+async function handleSend(params, callAgent) {
+	const message = params?.message;
+	if (!message || typeof message !== "string") throw new Error("params.message is required");
+	const sessionId = params?.sessionId;
+	const response = await callAgent(message, {
+		sessionId,
+		source: "pi-rpc"
+	});
+	return {
+		response,
+		sessionId: sessionId || "default"
+	};
+}
+function handleChatsList(getSessions) {
+	const chats = getSessions ? getSessions() : [];
+	return { chats };
+}
+var init_pi_rpc = require_chunk.__esm({ "packages/core/src/agent/pi-rpc.ts"() {} });
+
+//#endregion
+//#region packages/core/src/agent/runner.ts
+async function runAgent(opts) {
+	const cfg = await fs_extra.default.readJson(require_paths.getConfigPath()).catch(() => null);
+	if (!cfg) {
+		console.log(chalk.default.red("\n  ✖  No configuration found. Run: hyperclaw init\n"));
+		return;
+	}
+	const thinkingBudget = THINKING_BUDGET[opts.thinking];
+	const model = opts.model || cfg.provider?.modelId || "openrouter/auto";
+	console.log(chalk.default.bold.cyan("\n  ⚡ HYPERCLAW AGENT RUN\n"));
+	console.log(`  ${chalk.default.gray("Model:")}     ${model}`);
+	console.log(`  ${chalk.default.gray("Thinking:")} ${opts.thinking} (budget: ${thinkingBudget} tokens)`);
+	console.log(`  ${chalk.default.gray("Session:")}  ${opts.sessionId || "ephemeral"}`);
+	console.log();
+	const spinner = (0, ora.default)(opts.parallel ? "Planning & running sub-agents in parallel..." : opts.multiStep ? "Planning & running steps..." : "Thinking...").start();
+	const thinkingLines = [];
+	const engineOpts = {
+		sessionId: opts.sessionId,
+		source: "cli",
+		elevated: true,
+		modelOverride: opts.model,
+		workspace: opts.workspace,
+		thinkingBudget,
+		onToken: () => {},
+		onThinking: opts.verbose ? (t) => thinkingLines.push(t) : void 0
+	};
+	const result = opts.parallel ? await (await Promise.resolve().then(() => require("./orchestrator-Cg1vgEHb.js"))).runMultiStepParallel(opts.message, engineOpts) : opts.multiStep ? await (await Promise.resolve().then(() => require("./orchestrator-Cg1vgEHb.js"))).runMultiStep(opts.message, engineOpts) : await require_engine.runAgentEngine(opts.message, engineOpts);
+	spinner.stop();
+	if (result.error && result.error !== "no_api_key") {
+		console.log(chalk.default.red(`\n  ✖  Error: ${result.text}\n`));
+		if (result.error === "no_api_key") console.log(chalk.default.gray("  Run: hyperclaw config set-key"));
+		return;
+	}
+	if (thinkingLines.length > 0 && opts.verbose) {
+		console.log(chalk.default.dim("\n  ── Thinking ──\n"));
+		for (const line of thinkingLines) console.log(chalk.default.dim("  " + line.split("\n").join("\n  ")));
+		console.log();
+	}
+	console.log(chalk.default.bold("\n  Response:\n"));
+	console.log("  " + (result.text || "(empty)").split("\n").join("\n  "));
+	if (result.usage) {
+		console.log(chalk.default.gray(`\n  Tokens — input: ${result.usage.input}  output: ${result.usage.output}`));
+		if (result.usage.cacheRead) console.log(chalk.default.gray(`  Cache read: ${result.usage.cacheRead} tokens`));
+	}
+	console.log();
+}
+var THINKING_BUDGET;
+var init_runner = require_chunk.__esm({ "packages/core/src/agent/runner.ts"() {
+	require_src.init_src();
+	require_engine.init_engine();
+	THINKING_BUDGET = {
+		high: 1e4,
+		medium: 4e3,
+		low: 1e3,
+		none: 0
+	};
+} });
+
+//#endregion
+//#region packages/core/src/agent/acp.ts
+var ACPThreadManager;
+var init_acp = require_chunk.__esm({ "packages/core/src/agent/acp.ts"() {
+	ACPThreadManager = class extends events.EventEmitter {
+		threadsDir;
+		constructor() {
+			super();
+			this.threadsDir = path.default.join(os.default.homedir(), ".hyperclaw", "threads");
+			fs_extra.default.ensureDirSync(this.threadsDir);
+		}
+		threadPath(id) {
+			return path.default.join(this.threadsDir, `${id}.json`);
+		}
+		async create(options) {
+			if (options.resumeSessionId) {
+				const existing = await this.get(options.resumeSessionId);
+				if (existing) return existing;
+			}
+			const id = crypto.default.randomBytes(8).toString("hex");
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const thread = {
+				id,
+				name: options.name || `Thread ${id.slice(0, 6)}`,
+				channelId: options.channelId,
+				agentRole: options.agentRole || "subagent",
+				workspace: path.default.join(os.default.homedir(), ".hyperclaw"),
+				status: "active",
+				model: options.model || "openrouter/auto",
+				messages: options.systemPrompt ? [{
+					id: "sys-0",
+					threadId: id,
+					role: "system",
+					content: options.systemPrompt,
+					timestamp: now
+				}] : [],
+				createdAt: now,
+				lastActiveAt: now,
+				metadata: options.metadata || {}
+			};
+			await this.save(thread);
+			this.emit("thread:created", thread);
+			return thread;
+		}
+		async get(id) {
+			try {
+				return await fs_extra.default.readJson(this.threadPath(id));
+			} catch {
+				return null;
+			}
+		}
+		async save(thread) {
+			await fs_extra.default.writeJson(this.threadPath(thread.id), thread, { spaces: 2 });
+		}
+		async append(threadId, message) {
+			const thread = await this.get(threadId);
+			if (!thread) throw new Error(`Thread not found: ${threadId}`);
+			const msg = {
+				...message,
+				id: crypto.default.randomBytes(4).toString("hex"),
+				threadId,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			thread.messages.push(msg);
+			thread.lastActiveAt = msg.timestamp;
+			await this.save(thread);
+			this.emit("message:appended", {
+				thread,
+				message: msg
+			});
+			return msg;
+		}
+		async list(filter) {
+			const files = await fs_extra.default.readdir(this.threadsDir);
+			const threads = [];
+			for (const f of files.filter((f$1) => f$1.endsWith(".json"))) try {
+				const t = await fs_extra.default.readJson(path.default.join(this.threadsDir, f));
+				if (filter?.channelId && t.channelId !== filter.channelId) continue;
+				if (filter?.status && t.status !== filter.status) continue;
+				threads.push(t);
+			} catch {}
+			return threads.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+		}
+		async terminate(threadId) {
+			const thread = await this.get(threadId);
+			if (!thread) return;
+			thread.status = "terminated";
+			await this.save(thread);
+			this.emit("thread:terminated", thread);
+		}
+		async pause(threadId) {
+			const thread = await this.get(threadId);
+			if (!thread) return;
+			thread.status = "paused";
+			await this.save(thread);
+		}
+		async resume(threadId) {
+			const thread = await this.get(threadId);
+			if (!thread) return;
+			thread.status = "active";
+			await this.save(thread);
+		}
+		showList(threads) {
+			console.log(chalk.default.bold.cyan("\n  🧵 ACP THREADS\n"));
+			if (threads.length === 0) {
+				console.log(chalk.default.gray("  No threads. Create with: hyperclaw agent --message \"...\" --new-thread\n"));
+				return;
+			}
+			for (const t of threads) {
+				const statusColor = {
+					active: chalk.default.green,
+					idle: chalk.default.cyan,
+					paused: chalk.default.yellow,
+					terminated: chalk.default.gray
+				}[t.status];
+				const roleLabel = {
+					orchestrator: chalk.default.magenta("[orchestrator]"),
+					subagent: chalk.default.cyan("[subagent]"),
+					specialist: chalk.default.blue("[specialist]")
+				}[t.agentRole];
+				const age = Math.round((Date.now() - new Date(t.lastActiveAt).getTime()) / 1e3 / 60);
+				const ageLabel = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+				console.log(`  ${statusColor("●")} ${chalk.default.white(t.name)} ${chalk.default.gray(t.id)}`);
+				console.log(`    ${roleLabel}  ${chalk.default.gray(`model: ${t.model}`)}  ${chalk.default.gray(`${t.messages.length} messages`)}  ${chalk.default.gray(ageLabel)}`);
+				if (t.channelId) console.log(`    ${chalk.default.gray(`channel: ${t.channelId}`)}`);
+				console.log();
+			}
+		}
+	};
+} });
+
+//#endregion
+//#region packages/core/src/agent/surface-parity.ts
+/** Single source of truth for bot/CLI help. */
+function getAgentHelp(surface) {
+	const lines = COMMANDS.map((c) => `${c.cmd} — ${c.desc}`);
+	if (surface === "telegram") return `🦅 *HyperClaw Commands*\n\n${lines.join("\n")}\n\nGroups: @mention or reply to bot to activate.`;
+	if (surface === "discord") return `🦅 **HyperClaw Commands**\n\n${lines.join("\n")}\n\nGroups: mention or reply to activate.`;
+	return `🦅 HyperClaw Commands\n\n${lines.join("\n")}`;
+}
+/** Format agent response for display (optional header). */
+function formatAgentResponse(text, surface) {
+	if (!text || text.startsWith("Error:")) return text;
+	if (surface === "telegram") return `🦅 *Agent*\n\n${text}`;
+	if (surface === "discord") return `🦅 **Agent**\n\n${text}`;
+	return text;
+}
+var COMMANDS;
+var init_surface_parity = require_chunk.__esm({ "packages/core/src/agent/surface-parity.ts"() {
+	COMMANDS = [
+		{
+			cmd: "/status",
+			desc: "Gateway status"
+		},
+		{
+			cmd: "/restart",
+			desc: "Restart gateway"
+		},
+		{
+			cmd: "/logs [n]",
+			desc: "Last N log lines (default 20)"
+		},
+		{
+			cmd: "/approve <channel> <code>",
+			desc: "Approve DM pairing"
+		},
+		{
+			cmd: "/channels",
+			desc: "List active channels"
+		},
+		{
+			cmd: "/hook list",
+			desc: "List hooks"
+		},
+		{
+			cmd: "/hook on <id>",
+			desc: "Enable hook"
+		},
+		{
+			cmd: "/hook off <id>",
+			desc: "Disable hook"
+		},
+		{
+			cmd: "/agent <message>",
+			desc: "Talk to your AI"
+		},
+		{
+			cmd: "Voice note",
+			desc: "Transcribe + send to AI"
+		},
+		{
+			cmd: "/secrets",
+			desc: "Secrets audit summary"
+		},
+		{
+			cmd: "/security",
+			desc: "Security audit summary"
+		},
+		{
+			cmd: "/help",
+			desc: "This help message"
+		}
+	];
+} });
+
+//#endregion
+//#region packages/core/src/index.ts
+var src_exports = {};
+require_chunk.__export(src_exports, {
+	ACPThreadManager: () => ACPThreadManager,
+	AutoMemory: () => require_memory_auto.AutoMemory,
+	InferenceEngine: () => require_inference.InferenceEngine,
+	appendMemory: () => require_memory_auto.appendMemory,
+	buildSkillsContext: () => require_skill_loader.buildSkillsContext,
+	clearMemory: () => require_memory_auto.clearMemory,
+	createFileSessionStore: () => require_session_store.createFileSessionStore,
+	createPiRPCHandler: () => createPiRPCHandler,
+	extractExecutionContract: () => require_skill_runtime.extractExecutionContract,
+	extractFactsLocally: () => require_memory_auto.extractFactsLocally,
+	formatAgentResponse: () => formatAgentResponse,
+	getAgentHelp: () => getAgentHelp,
+	getBrowserTools: () => require_browser_tools.getBrowserTools,
+	getBuiltinTools: () => require_inference.getBuiltinTools,
+	getConfigPath: () => require_paths.getConfigPath,
+	getEnvFilePath: () => require_paths.getEnvFilePath,
+	getExtractionTools: () => require_extraction_tools.getExtractionTools,
+	getHyperClawDir: () => require_paths.getHyperClawDir,
+	getPCAccessTools: () => require_pc_access.getPCAccessTools,
+	getSessionsTools: () => require_sessions_tools.getSessionsTools,
+	getSkillCapabilities: () => require_skill_loader.getSkillCapabilities,
+	getSkillInvokeTools: () => require_skill_runtime.getSkillInvokeTools,
+	getVisionTools: () => require_vision_tools.getVisionTools,
+	getWebsiteWatchTools: () => require_website_watch_tools.getWebsiteWatchTools,
+	invokeSkill: () => require_skill_runtime.invokeSkill,
+	loadPCAccessConfig: () => require_pc_access.loadPCAccessConfig,
+	loadSkills: () => require_skill_loader.loadSkills,
+	loadSkillsContext: () => require_engine.loadSkillsContext,
+	loadWorkspaceContext: () => require_engine.loadWorkspaceContext,
+	planSteps: () => require_orchestrator.planSteps,
+	readMemory: () => require_memory_auto.readMemory,
+	reloadSkills: () => require_skill_loader.reloadSkills,
+	resolveTools: () => require_engine.resolveTools,
+	runAgent: () => runAgent,
+	runAgentEngine: () => require_engine.runAgentEngine,
+	runMultiStep: () => require_orchestrator.runMultiStep,
+	runMultiStepParallel: () => require_orchestrator.runMultiStepParallel,
+	runWithPlan: () => require_orchestrator.runWithPlan,
+	saveMemoryDirect: () => require_memory_auto.saveMemoryDirect,
+	savePCAccessConfig: () => require_pc_access.savePCAccessConfig,
+	searchMemory: () => require_memory_auto.searchMemory,
+	showMemory: () => require_memory_auto.showMemory,
+	showPCAccessStatus: () => require_pc_access.showPCAccessStatus,
+	validateSkill: () => require_skill_loader.validateSkill
+});
+var init_src$1 = require_chunk.__esm({ "packages/core/src/index.ts"() {
+	require_src.init_src();
+	require_engine.init_engine();
+	require_inference.init_inference();
+	require_session_store.init_session_store();
+	require_orchestrator.init_orchestrator();
+	require_skill_runtime.init_skill_runtime();
+	require_memory_auto.init_memory_auto();
+	require_skill_loader.init_skill_loader();
+	init_pi_rpc();
+	require_sessions_tools.init_sessions_tools();
+	require_pc_access.init_pc_access();
+	require_browser_tools.init_browser_tools();
+	require_extraction_tools.init_extraction_tools();
+	require_website_watch_tools.init_website_watch_tools();
+	require_vision_tools.init_vision_tools();
+	init_runner();
+	init_acp();
+	init_surface_parity();
+} });
+
+//#endregion
+Object.defineProperty(exports, 'ACPThreadManager', {
+  enumerable: true,
+  get: function () {
+    return ACPThreadManager;
+  }
+});
+Object.defineProperty(exports, 'createPiRPCHandler', {
+  enumerable: true,
+  get: function () {
+    return createPiRPCHandler;
+  }
+});
+Object.defineProperty(exports, 'formatAgentResponse', {
+  enumerable: true,
+  get: function () {
+    return formatAgentResponse;
+  }
+});
+Object.defineProperty(exports, 'getAgentHelp', {
+  enumerable: true,
+  get: function () {
+    return getAgentHelp;
+  }
+});
+Object.defineProperty(exports, 'init_src', {
+  enumerable: true,
+  get: function () {
+    return init_src$1;
+  }
+});
+Object.defineProperty(exports, 'runAgent', {
+  enumerable: true,
+  get: function () {
+    return runAgent;
+  }
+});
+Object.defineProperty(exports, 'src_exports', {
+  enumerable: true,
+  get: function () {
+    return src_exports;
+  }
+});