hyperclaw 4.0.2 → 5.0.0

package/dist/orchestrator-DmnEvMaL.js

@@ -0,0 +1,189 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+
+//#region packages/core/src/agent/orchestrator.ts
+/** Parse parallel plan into waves: [['A'], ['B','C'], ['D']] = A then B||C then D. */
+function parseParallelWaves(text) {
+	const waves = [];
+	const lines = (text || "").trim().split(/\n/);
+	for (const line of lines) {
+		const m = line.match(/^\s*\d+\.\s*(.+)$/);
+		if (!m) continue;
+		const parts = m[1].split(/\|/).map((s) => s.trim()).filter(Boolean);
+		if (parts.length > 0) waves.push(parts);
+	}
+	return waves;
+}
+/** Parse "1. X\n2. Y" into step strings. */
+function parseSteps(text) {
+	const steps = [];
+	const lines = (text || "").trim().split(/\n/);
+	for (const line of lines) {
+		const m = line.match(/^\s*\d+\.\s*(.+)$/);
+		if (m) steps.push(m[1].trim());
+	}
+	return steps.length > 0 ? steps : [];
+}
+/** Multi-step with retry, session context, checkpointing, error recovery. */
+async function runMultiStep(goal, opts) {
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-Da4JMNpI.js"));
+	const maxRetries = opts.maxStepRetries ?? 2;
+	const checkpointable = opts.checkpointable ?? false;
+	let steps;
+	let results = [];
+	let startIndex = 0;
+	if (opts.checkpoint && opts.checkpoint.goal === goal && opts.checkpoint.steps.length > 0) {
+		steps = opts.checkpoint.steps;
+		results = [...opts.checkpoint.results ?? []];
+		startIndex = results.length;
+	} else {
+		const planOpts = opts.sessionId && opts.appendTranscript ? opts : {
+			...opts,
+			sessionId: opts.sessionId,
+			appendTranscript: opts.appendTranscript
+		};
+		const planResult = await runAgentEngine(`${PLAN_PROMPT}\n\nGoal: ${goal}`, planOpts);
+		steps = parseSteps(planResult.text);
+		if (steps.length === 0) return runAgentEngine(goal, opts);
+	}
+	let lastUsage;
+	for (let i = startIndex; i < steps.length; i++) {
+		const step = steps[i];
+		const ctx = results.length > 0 ? `Previous results:\n${results.map((r, j) => `Step ${j + 1}: ${r.slice(0, 400)}${r.length > 400 ? "..." : ""}`).join("\n")}\n\n` : "";
+		const message = `${ctx}Step ${i + 1}: ${step}`;
+		let lastErr;
+		let stepResult;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			stepResult = await runAgentEngine(message, opts);
+			if (stepResult.usage) lastUsage = stepResult.usage;
+			if (!stepResult.error) {
+				results.push(stepResult.text);
+				if (checkpointable && opts.onCheckpoint) await Promise.resolve(opts.onCheckpoint({
+					goal,
+					steps,
+					completedIndices: [...Array(results.length)].map((_, k) => k),
+					results: [...results]
+				}));
+				break;
+			}
+			lastErr = stepResult.error;
+			if (attempt < maxRetries && opts.onToken) opts.onToken(`[Retry ${attempt + 1}/${maxRetries} for step ${i + 1}…]\n`);
+		}
+		if (lastErr) {
+			const summary$1 = results.length > 0 ? results.map((r, j) => `**Step ${j + 1}**\n${r}`).join("\n\n---\n\n") + `\n\n**Step ${i + 1}** (failed): ${lastErr}` : `Step ${i + 1} failed: ${lastErr}`;
+			opts.onDone?.(summary$1);
+			return {
+				text: summary$1,
+				error: lastErr,
+				usage: lastUsage
+			};
+		}
+	}
+	const summary = results.map((r, i) => `**Step ${i + 1}**\n${r}`).join("\n\n---\n\n");
+	opts.onDone?.(summary);
+	return {
+		text: summary,
+		usage: lastUsage
+	};
+}
+/** Parallel sub-agents: plan waves → run each wave in parallel (Promise.all) → aggregate. */
+async function runMultiStepParallel(goal, opts) {
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-Da4JMNpI.js"));
+	const planOpts = {
+		...opts,
+		sessionId: void 0,
+		appendTranscript: void 0
+	};
+	const planResult = await runAgentEngine(`${PARALLEL_PLAN_PROMPT}\n\nGoal: ${goal}`, planOpts);
+	const waves = parseParallelWaves(planResult.text);
+	if (waves.length === 0) return runAgentEngine(goal, opts);
+	const allResults = [];
+	let lastUsage = planResult.usage;
+	for (let w = 0; w < waves.length; w++) {
+		const wave = waves[w];
+		const ctx = allResults.length > 0 ? `Previous results:\n${allResults.map((r, j) => `Result ${j + 1}: ${r.slice(0, 300)}${r.length > 300 ? "..." : ""}`).join("\n")}\n\n` : "";
+		const messages = wave.map((step, i) => `${ctx}Sub-task ${w + 1}.${i + 1}: ${step}`);
+		const runOpts = {
+			...opts,
+			onToken: void 0,
+			onDone: void 0
+		};
+		const results = await Promise.all(messages.map((msg) => runAgentEngine(msg, runOpts)));
+		for (const r of results) {
+			if (r.usage) lastUsage = r.usage;
+			if (r.error) {
+				const summary$1 = allResults.map((r0, j) => `**Sub-agent ${j + 1}**\n${r0}`).join("\n\n---\n\n") + `\n\n**Failed**\n${r.text}`;
+				opts.onDone?.(summary$1);
+				return {
+					text: summary$1,
+					error: r.error,
+					usage: lastUsage
+				};
+			}
+			allResults.push(r.text);
+		}
+	}
+	const summary = allResults.map((r, i) => `**Sub-agent ${i + 1}**\n${r}`).join("\n\n---\n\n");
+	opts.onDone?.(summary);
+	return {
+		text: summary,
+		usage: lastUsage
+	};
+}
+/** Single-run passthrough (unchanged). */
+async function runWithPlan(message, opts) {
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-Da4JMNpI.js"));
+	return runAgentEngine(message, opts);
+}
+async function planSteps(goal) {
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-Da4JMNpI.js"));
+	const r = await runAgentEngine(`${PLAN_PROMPT}\n\nGoal: ${goal}`, {});
+	return parseSteps(r.text).map((g) => ({ goal: g }));
+}
+var PLAN_PROMPT, PARALLEL_PLAN_PROMPT;
+var init_orchestrator = require_chunk.__esm({ "packages/core/src/agent/orchestrator.ts"() {
+	PLAN_PROMPT = `Break this goal into 1-4 concrete, executable steps. Output ONLY numbered lines.
+Format: 1. step one
+2. step two
+...
+No other text.`;
+	PARALLEL_PLAN_PROMPT = `Break this goal into 2-6 steps. Steps that can run IN PARALLEL (independent) put on the SAME line with | between them.
+Format:
+1. step one
+2. step A | step B
+3. step three
+Example: "Compare Python vs Node for APIs" → 1. research Python for APIs | research Node for APIs
+2. summarize comparison
+Output ONLY numbered lines. No other text.`;
+} });
+
+//#endregion
+Object.defineProperty(exports, 'init_orchestrator', {
+  enumerable: true,
+  get: function () {
+    return init_orchestrator;
+  }
+});
+Object.defineProperty(exports, 'planSteps', {
+  enumerable: true,
+  get: function () {
+    return planSteps;
+  }
+});
+Object.defineProperty(exports, 'runMultiStep', {
+  enumerable: true,
+  get: function () {
+    return runMultiStep;
+  }
+});
+Object.defineProperty(exports, 'runMultiStepParallel', {
+  enumerable: true,
+  get: function () {
+    return runMultiStepParallel;
+  }
+});
+Object.defineProperty(exports, 'runWithPlan', {
+  enumerable: true,
+  get: function () {
+    return runWithPlan;
+  }
+});

package/dist/orchestrator-RI3bpqqc.js

@@ -0,0 +1,6 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_orchestrator = require('./orchestrator-DmnEvMaL.js');
+
+require_orchestrator.init_orchestrator();
+exports.runMultiStep = require_orchestrator.runMultiStep;
+exports.runMultiStepParallel = require_orchestrator.runMultiStepParallel;

package/dist/pairing-6iM27aD8.js

@@ -0,0 +1,196 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+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"));
+
+//#region src/channels/pairing.ts
+const CREDENTIALS_DIR = path.default.join(os.default.homedir(), ".hyperclaw", "credentials");
+const CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const CODE_LENGTH = 8;
+const EXPIRY_MS = 60 * 60 * 1e3;
+const MAX_PENDING_PER_CHANNEL = 3;
+function generateCode() {
+	const bytes = crypto.default.randomBytes(CODE_LENGTH);
+	return Array.from(bytes).map((b) => CODE_ALPHABET[b % CODE_ALPHABET.length]).join("");
+}
+function pendingFile(channelId) {
+	return path.default.join(CREDENTIALS_DIR, `${channelId}-pairing.json`);
+}
+function allowFromFile(channelId, accountId = "default") {
+	const suffix = accountId === "default" ? "" : `-${accountId}`;
+	return path.default.join(CREDENTIALS_DIR, `${channelId}${suffix}-allowFrom.json`);
+}
+async function readPending(channelId) {
+	try {
+		const data = await fs_extra.default.readJson(pendingFile(channelId));
+		return Array.isArray(data) ? data : [];
+	} catch {
+		return [];
+	}
+}
+async function writePending(channelId, entries) {
+	await fs_extra.default.ensureDir(CREDENTIALS_DIR);
+	await fs_extra.default.writeJson(pendingFile(channelId), entries, {
+		spaces: 2,
+		mode: 384
+	});
+}
+async function readAllowFrom(channelId, accountId = "default") {
+	try {
+		return await fs_extra.default.readJson(allowFromFile(channelId, accountId));
+	} catch {
+		return {
+			senderIds: [],
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+}
+async function writeAllowFrom(channelId, store, accountId = "default") {
+	await fs_extra.default.ensureDir(CREDENTIALS_DIR);
+	await fs_extra.default.writeJson(allowFromFile(channelId, accountId), store, {
+		spaces: 2,
+		mode: 384
+	});
+}
+var PairingStore = class {
+	channelId;
+	accountId;
+	constructor(channelId, accountId = "default") {
+		this.channelId = channelId;
+		this.accountId = accountId;
+	}
+	async isApproved(senderId) {
+		const store = await readAllowFrom(this.channelId, this.accountId);
+		return store.senderIds.includes(senderId);
+	}
+	/**
+	* Returns the pairing code to send to the user, or null if already pending
+	* (code is resent only once per hour per sender).
+	*/
+	async createRequest(senderId) {
+		const now = Date.now();
+		const entries = (await readPending(this.channelId)).filter((e) => {
+			return new Date(e.expiresAt).getTime() > now;
+		});
+		const existing = entries.find((e) => e.senderId === senderId && e.channelId === this.channelId);
+		if (existing) return existing.code;
+		const channelPending = entries.filter((e) => e.channelId === this.channelId && e.accountId === this.accountId);
+		if (channelPending.length >= MAX_PENDING_PER_CHANNEL) return null;
+		const code = generateCode();
+		const entry = {
+			code,
+			channelId: this.channelId,
+			accountId: this.accountId,
+			senderId,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			expiresAt: new Date(now + EXPIRY_MS).toISOString()
+		};
+		entries.push(entry);
+		await writePending(this.channelId, entries);
+		return code;
+	}
+	/**
+	* Called when a sender submits a code.
+	* Returns true if the code was valid and the sender is now approved.
+	*/
+	async verify(code, senderId) {
+		const now = Date.now();
+		const entries = await readPending(this.channelId);
+		const idx = entries.findIndex((e) => e.code === code.toUpperCase() && e.channelId === this.channelId && e.accountId === this.accountId && new Date(e.expiresAt).getTime() > now);
+		if (idx === -1) return false;
+		const entry = entries[idx];
+		entries.splice(idx, 1);
+		await writePending(this.channelId, entries);
+		const store = await readAllowFrom(this.channelId, this.accountId);
+		if (!store.senderIds.includes(entry.senderId)) store.senderIds.push(entry.senderId);
+		store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeAllowFrom(this.channelId, store, this.accountId);
+		return true;
+	}
+	async listPending() {
+		const now = Date.now();
+		const entries = await readPending(this.channelId);
+		return entries.filter((e) => e.channelId === this.channelId && e.accountId === this.accountId && new Date(e.expiresAt).getTime() > now);
+	}
+	async cliApprove(code) {
+		const now = Date.now();
+		const entries = await readPending(this.channelId);
+		const idx = entries.findIndex((e) => e.code === code.toUpperCase() && e.channelId === this.channelId && e.accountId === this.accountId && new Date(e.expiresAt).getTime() > now);
+		if (idx === -1) return false;
+		const entry = entries[idx];
+		entries.splice(idx, 1);
+		await writePending(this.channelId, entries);
+		const store = await readAllowFrom(this.channelId, this.accountId);
+		if (!store.senderIds.includes(entry.senderId)) store.senderIds.push(entry.senderId);
+		store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeAllowFrom(this.channelId, store, this.accountId);
+		return true;
+	}
+};
+const SUPPORTED_CHANNELS = [
+	"telegram",
+	"whatsapp",
+	"signal",
+	"imessage",
+	"discord",
+	"slack",
+	"feishu"
+];
+var GlobalPairingManager = class {
+	async showList(channelFilter) {
+		const now = Date.now();
+		const channels = channelFilter ? [channelFilter] : SUPPORTED_CHANNELS;
+		console.log(chalk.default.bold.cyan("\n  🔑 PAIRING CODES\n"));
+		let total = 0;
+		for (const ch of channels) {
+			let pending = [];
+			try {
+				const raw = await readPending(ch);
+				pending = raw.filter((e) => new Date(e.expiresAt).getTime() > now);
+			} catch {}
+			if (pending.length === 0) continue;
+			total += pending.length;
+			console.log(chalk.default.yellow(`  ─── ${ch} ───`));
+			for (const e of pending) {
+				const expiresIn = Math.round((new Date(e.expiresAt).getTime() - now) / 6e4);
+				const acctSuffix = e.accountId !== "default" ? chalk.default.gray(` [${e.accountId}]`) : "";
+				console.log(`  ${chalk.default.yellow("○")} ${chalk.default.bold(e.code)}  sender: ${chalk.default.white(e.senderId)}${acctSuffix}  expires: ${chalk.default.gray(`${expiresIn}m`)}`);
+			}
+			console.log();
+		}
+		if (total === 0) console.log(chalk.default.gray(`  No pending pairing requests${channelFilter ? ` for ${channelFilter}` : ""}.\n`));
+	}
+	async cliApprove(channelId, code, accountId = "default") {
+		if (!SUPPORTED_CHANNELS.includes(channelId)) {
+			console.log(chalk.default.red(`\n  ✖  Unknown channel: ${channelId}`));
+			console.log(chalk.default.gray(`     Supported: ${SUPPORTED_CHANNELS.join(", ")}\n`));
+			return;
+		}
+		const store = new PairingStore(channelId, accountId);
+		const ok = await store.cliApprove(code);
+		if (ok) {
+			console.log(chalk.default.green(`\n  ✔  Pairing approved — ${channelId} code ${code.toUpperCase()}`));
+			console.log(chalk.default.gray(`  Sender added to ${channelId}${accountId !== "default" ? `-${accountId}` : ""}-allowFrom.json\n`));
+		} else console.log(chalk.default.red(`\n  ✖  Code not found, expired, or already used: ${channelId} ${code.toUpperCase()}\n`));
+	}
+	async getApprovedSenders(channelId, accountId = "default") {
+		const store = await readAllowFrom(channelId, accountId);
+		return store.senderIds;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'GlobalPairingManager', {
+  enumerable: true,
+  get: function () {
+    return GlobalPairingManager;
+  }
+});
+Object.defineProperty(exports, 'PairingStore', {
+  enumerable: true,
+  get: function () {
+    return PairingStore;
+  }
+});

package/dist/pairing-dGoiGepK.js

@@ -0,0 +1,4 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_pairing = require('./pairing-6iM27aD8.js');
+
+exports.PairingStore = require_pairing.PairingStore;

package/dist/pc-access-CgCsYrpt.js

@@ -0,0 +1,8 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+require('./paths-AIyBxIzm.js');
+require('./src-DIc-L2IG.js');
+const require_pc_access = require('./pc-access-_iH2aorG.js');
+
+require_pc_access.init_pc_access();
+exports.getPCAccessTools = require_pc_access.getPCAccessTools;
+exports.loadPCAccessConfig = require_pc_access.loadPCAccessConfig;