hyperclaw 4.0.2 → 5.0.1

package/dist/orchestrator-BovkM63z.js

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

package/dist/orchestrator-DSbpkP1X.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-BJUpRUOv.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-BJUpRUOv.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-BJUpRUOv.js"));
+	return runAgentEngine(message, opts);
+}
+async function planSteps(goal) {
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-BJUpRUOv.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-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/osint-B4_m3VHQ.js

@@ -0,0 +1,277 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const inquirer = require_chunk.__toESM(require("inquirer"));
+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"));
+
+//#region src/commands/osint.ts
+const HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+const CONFIG_FILE = path.default.join(HC_DIR, "hyperclaw.json");
+const OSINT_PROFILE_FILE = path.default.join(HC_DIR, "osint-profile.json");
+const MODE_DESCRIPTIONS = {
+	recon: "Passive reconnaissance — WHOIS, DNS, subdomains, public info gathering",
+	bugbounty: "Bug bounty workflow — target scope, vulnerability research, report drafting",
+	pentest: "Penetration testing — active recon, service enumeration, exploit research",
+	footprint: "Digital footprint — social media, email leaks, username tracking",
+	custom: "Custom — configure your own tools and system prompt"
+};
+const MODE_SYSTEM_PROMPTS = {
+	recon: `You are a professional OSINT analyst specializing in passive reconnaissance.
+Your goal is to gather publicly available information about the target without triggering detection.
+Use DNS lookups, WHOIS data, web scraping, and public databases.
+Always cite sources and stay within legal boundaries.
+Never attempt active exploitation — only passive information gathering.`,
+	bugbounty: `You are an experienced bug bounty hunter working within an authorized scope.
+Your goal is to identify security vulnerabilities in web applications and infrastructure.
+Follow responsible disclosure principles. Report findings clearly with reproduction steps.
+Focus on: XSS, SQLi, SSRF, authentication issues, business logic flaws, IDOR.
+Use tools methodically. Document everything for your report.`,
+	pentest: `You are a professional penetration tester with explicit written authorization.
+Conduct a thorough security assessment following the PTES methodology.
+Phases: Intelligence Gathering → Scanning → Exploitation → Post-Exploitation → Reporting.
+Document all findings with CVSS scores. Stay within defined scope at all times.
+Never exfiltrate real data — only demonstrate access.`,
+	footprint: `You are a digital forensics investigator mapping a target's online presence.
+Your goal is to build a comprehensive profile using only public sources.
+Search social media, data breach databases (HaveIBeenPwned, Dehashed), LinkedIn, GitHub.
+Create a timeline of online activity. Identify connected accounts, email patterns, usernames.
+This is for defensive intelligence gathering and authorized investigations only.`,
+	custom: `You are a security researcher with access to OSINT and analysis tools.
+Use available tools to assist with the research task.`
+};
+const MODE_MCP_SERVERS = {
+	recon: ["mcp-browser", "mcp-filesystem"],
+	bugbounty: [
+		"mcp-browser",
+		"mcp-filesystem",
+		"mcp-github"
+	],
+	pentest: [
+		"mcp-browser",
+		"mcp-filesystem",
+		"mcp-terminal",
+		"mcp-github"
+	],
+	footprint: ["mcp-browser", "mcp-filesystem"],
+	custom: ["mcp-browser", "mcp-filesystem"]
+};
+function printBanner() {
+	console.log();
+	console.log(chalk.default.red.bold("  ██████╗ ███████╗██╗███╗   ██╗████████╗"));
+	console.log(chalk.default.red.bold("  ██╔═══██╗██╔════╝██║████╗  ██║╚══██╔══╝"));
+	console.log(chalk.default.yellow.bold("  ██║   ██║███████╗██║██╔██╗ ██║   ██║   "));
+	console.log(chalk.default.yellow.bold("  ██║   ██║╚════██║██║██║╚██╗██║   ██║   "));
+	console.log(chalk.default.red.bold("  ╚██████╔╝███████║██║██║ ╚████║   ██║   "));
+	console.log(chalk.default.red.bold("   ╚═════╝ ╚══════╝╚═╝╚═╝  ╚═══╝   ╚═╝   "));
+	console.log();
+	console.log(chalk.default.gray("  HyperClaw OSINT / Ethical Hacking Mode"));
+	console.log(chalk.default.gray("  ────────────────────────────────────────────"));
+	console.log(chalk.default.yellow("  ⚠️  For authorized security research only."));
+	console.log(chalk.default.yellow("  ⚠️  Always have explicit written permission."));
+	console.log();
+}
+async function osintSetup(options) {
+	printBanner();
+	if (options.show) {
+		try {
+			const profile$1 = await fs_extra.default.readJson(OSINT_PROFILE_FILE);
+			console.log(chalk.default.cyan.bold("  Current OSINT Profile:\n"));
+			console.log(`  Mode:    ${chalk.default.yellow(profile$1.mode)}`);
+			console.log(`  Target:  ${chalk.default.white(profile$1.target || "(not set)")}`);
+			console.log(`  Type:    ${profile$1.targetType || "N/A"}`);
+			console.log(`  MCP:     ${profile$1.mcpServers.join(", ")}`);
+			console.log(`  Created: ${profile$1.createdAt}`);
+			if (profile$1.notes) console.log(`  Notes:   ${profile$1.notes}`);
+			console.log();
+		} catch {
+			console.log(chalk.default.gray("  No OSINT profile saved yet. Run: hyperclaw osint setup\n"));
+		}
+		return;
+	}
+	if (options.reset) {
+		await fs_extra.default.remove(OSINT_PROFILE_FILE);
+		console.log(chalk.default.green("  ✔  OSINT profile cleared.\n"));
+		return;
+	}
+	console.log(chalk.default.bold("  Select OSINT workflow:\n"));
+	for (const [mode$1, desc] of Object.entries(MODE_DESCRIPTIONS)) console.log(`  ${chalk.default.cyan(mode$1.padEnd(12))} ${chalk.default.gray(desc)}`);
+	console.log();
+	const { mode } = await inquirer.default.prompt([{
+		type: "list",
+		name: "mode",
+		message: "Workflow:",
+		choices: Object.keys(MODE_DESCRIPTIONS).map((m) => ({
+			name: `${m.padEnd(12)} — ${MODE_DESCRIPTIONS[m]}`,
+			value: m
+		})),
+		default: options.mode || "recon"
+	}]);
+	const { hasTarget } = await inquirer.default.prompt([{
+		type: "confirm",
+		name: "hasTarget",
+		message: "Set a target for this session?",
+		default: true
+	}]);
+	let target;
+	let targetType;
+	if (hasTarget) {
+		const resp = await inquirer.default.prompt([{
+			type: "list",
+			name: "targetType",
+			message: "Target type:",
+			choices: [
+				"domain",
+				"ip",
+				"username",
+				"email",
+				"org",
+				"custom"
+			]
+		}, {
+			type: "input",
+			name: "target",
+			message: "Target value (e.g. example.com):",
+			validate: (v) => v.trim().length > 0 || "Required"
+		}]);
+		target = resp.target.trim();
+		targetType = resp.targetType;
+	}
+	const { notes } = await inquirer.default.prompt([{
+		type: "input",
+		name: "notes",
+		message: "Session notes (optional, e.g. \"HackerOne program XYZ\"):"
+	}]);
+	console.log();
+	const { confirmed } = await inquirer.default.prompt([{
+		type: "confirm",
+		name: "confirmed",
+		message: chalk.default.yellow("I confirm I have explicit written authorization to test this target."),
+		default: false
+	}]);
+	if (!confirmed) {
+		console.log(chalk.default.red("\n  Aborted. OSINT mode requires authorization confirmation.\n"));
+		return;
+	}
+	const spinner = (0, ora.default)("Applying OSINT configuration...").start();
+	const mcpServers = MODE_MCP_SERVERS[mode];
+	const systemPrompt = MODE_SYSTEM_PROMPTS[mode];
+	const profile = {
+		mode,
+		target,
+		targetType,
+		notes: notes || void 0,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		mcpServers,
+		systemPromptOverride: systemPrompt
+	};
+	await fs_extra.default.ensureDir(HC_DIR);
+	await fs_extra.default.writeJson(OSINT_PROFILE_FILE, profile, { spaces: 2 });
+	let config = {};
+	try {
+		config = await fs_extra.default.readJson(CONFIG_FILE);
+	} catch {}
+	if (!config.agent) config.agent = {};
+	const agent = config.agent;
+	agent.systemPromptOverride = systemPrompt;
+	agent.osintMode = mode;
+	if (target) agent.osintTarget = `${targetType}: ${target}`;
+	const mcpFile = path.default.join(HC_DIR, "mcp-servers.json");
+	let mcpServersJson = [];
+	try {
+		mcpServersJson = await fs_extra.default.readJson(mcpFile);
+	} catch {}
+	const extensionsDir = path.default.join(path.default.dirname(CONFIG_FILE), "..", "..");
+	const serverDefs = {
+		"mcp-filesystem": {
+			command: `node ${path.default.join(process.cwd(), "extensions/mcp-filesystem/server.mjs")}`,
+			label: "Filesystem (OSINT)"
+		},
+		"mcp-browser": {
+			command: `node ${path.default.join(process.cwd(), "extensions/mcp-browser/server.mjs")}`,
+			label: "Browser/Web (OSINT)"
+		},
+		"mcp-terminal": {
+			command: `node ${path.default.join(process.cwd(), "extensions/mcp-terminal/server.mjs")}`,
+			label: "Terminal (OSINT)"
+		},
+		"mcp-github": {
+			command: `node ${path.default.join(process.cwd(), "extensions/mcp-github/server.mjs")}`,
+			label: "GitHub (OSINT)"
+		}
+	};
+	for (const serverId of mcpServers) {
+		const already = mcpServersJson.find((s) => s.id === serverId);
+		if (!already && serverDefs[serverId]) mcpServersJson.push({
+			id: serverId,
+			name: serverDefs[serverId].label,
+			transport: "stdio",
+			command: serverDefs[serverId].command,
+			enabled: true,
+			addedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		else if (already) already.enabled = true;
+	}
+	await fs_extra.default.ensureDir(path.default.dirname(mcpFile));
+	await fs_extra.default.writeJson(mcpFile, mcpServersJson, { spaces: 2 });
+	await fs_extra.default.writeJson(CONFIG_FILE, config, { spaces: 2 });
+	spinner.succeed("OSINT configuration applied");
+	console.log();
+	console.log(chalk.default.bold.cyan("  ✔  HyperClaw is now in OSINT mode:\n"));
+	console.log(`  Workflow: ${chalk.default.yellow(mode)}`);
+	if (target) console.log(`  Target:   ${chalk.default.white(target)} ${chalk.default.gray(`(${targetType})`)}`);
+	console.log(`  MCP:      ${chalk.default.cyan(mcpServers.join(", "))}`);
+	console.log();
+	console.log(chalk.default.bold("  Start your session:"));
+	console.log(`  ${chalk.default.cyan("hyperclaw daemon start")}           — start the assistant`);
+	console.log(`  ${chalk.default.cyan("hyperclaw agent --message \"...\"")} — send a message from CLI`);
+	console.log();
+	console.log(chalk.default.bold("  Example prompts:"));
+	if (mode === "recon" && target) {
+		console.log(chalk.default.gray(`  "Perform passive recon on ${target}: WHOIS, DNS, subdomains"`));
+		console.log(chalk.default.gray(`  "Find all public GitHub repos for ${target}"`));
+		console.log(chalk.default.gray(`  "Search for email addresses associated with ${target}"`));
+	} else if (mode === "bugbounty") {
+		console.log(chalk.default.gray(`  "What are common vulnerabilities in web login forms?"`));
+		console.log(chalk.default.gray(`  "Draft a bug bounty report for an XSS vulnerability"`));
+		console.log(chalk.default.gray(`  "Help me test for SSRF on the /api/fetch endpoint"`));
+	} else if (mode === "pentest") {
+		console.log(chalk.default.gray(`  "Create a pentest report template for a web application"`));
+		console.log(chalk.default.gray(`  "What ports should I check on a Linux server?"`));
+		console.log(chalk.default.gray(`  "Explain how to test for SQLi safely in a controlled environment"`));
+	} else if (mode === "footprint") {
+		console.log(chalk.default.gray(`  "Search for the digital footprint of the username 'target_user'"`));
+		console.log(chalk.default.gray(`  "Check HaveIBeenPwned for emails from domain example.com"`));
+	}
+	console.log();
+	console.log(chalk.default.gray("  To view profile: hyperclaw osint --show"));
+	console.log(chalk.default.gray("  To reset:        hyperclaw osint --reset"));
+	console.log();
+}
+async function osintQuickStart(mode) {
+	printBanner();
+	console.log(chalk.default.bold("  Available OSINT workflows:\n"));
+	for (const [m, desc] of Object.entries(MODE_DESCRIPTIONS)) {
+		const isActive = m === mode;
+		const bullet = isActive ? chalk.default.green("▶") : chalk.default.gray("○");
+		console.log(`  ${bullet} ${chalk.default.cyan(m.padEnd(12))} ${chalk.default.white(desc)}`);
+	}
+	console.log();
+	console.log(chalk.default.bold("  Commands:\n"));
+	console.log(`  ${chalk.default.cyan("hyperclaw osint setup")}           — interactive OSINT session setup`);
+	console.log(`  ${chalk.default.cyan("hyperclaw osint --show")}          — show current profile`);
+	console.log(`  ${chalk.default.cyan("hyperclaw osint --reset")}         — clear OSINT profile`);
+	console.log();
+	console.log(chalk.default.bold("  MCP servers for OSINT:\n"));
+	console.log(`  ${chalk.default.cyan("mcp-browser")}    — web_fetch, web_search, dns_lookup, whois_lookup, extract_links`);
+	console.log(`  ${chalk.default.cyan("mcp-filesystem")} — read_file, write_file, search_files (for saving reports)`);
+	console.log(`  ${chalk.default.cyan("mcp-github")}     — list_repos, search_code, get_file`);
+	console.log(`  ${chalk.default.cyan("mcp-terminal")}   — run_command (pentest mode only, requires authorization)`);
+	console.log();
+	console.log(chalk.default.yellow("  ⚠️  Always operate within authorized scope and applicable laws.\n"));
+}
+
+//#endregion
+exports.osintQuickStart = osintQuickStart;
+exports.osintSetup = osintSetup;