@agenthippo-ai/agenthippo 0.1.0

package/out/scripts/analytics/workflows-collector.cjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/* Copyright (c) AgentHippo.ai. All rights reserved. */
+/* Workflows collector: fleet-workflows + history archives. */
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const BRAND_DIR = '.agent-hippo';
+const WORKFLOWS_DIRNAME = 'fleet-workflows';
+const HISTORY_DIRNAME = 'history';
+const DEFAULT_VIEW_ID = 'workflows';
+const KNOWN_WORKSPACES_FILE = 'known-workspaces.json';
+
+function resolveViewId() {
+	const fromEnv = (process.env.AGENTIDE_VIEW_ID || '').trim();
+	if (fromEnv) {
+		return fromEnv;
+	}
+	const viewRoot = (process.env.AGENTIDE_VIEW_ROOT || '').trim();
+	if (viewRoot) {
+		const base = path.basename(path.resolve(viewRoot));
+		if (base) {
+			return base;
+		}
+	}
+	return DEFAULT_VIEW_ID;
+}
+
+function resolveSnapshotFile(viewId = resolveViewId()) {
+	return `${viewId}.json`;
+}
+
+function getAgentHome() {
+	const fromEnv = (process.env.AGENTHIPPO_HOME || process.env.AGENT_HOME || '').trim();
+	return fromEnv ? path.resolve(fromEnv) : path.join(os.homedir(), BRAND_DIR);
+}
+
+function parsePathsMdWorkspace(pathsMdPath) {
+	try {
+		const text = fs.readFileSync(pathsMdPath, 'utf8');
+		const match = text.match(/\*\*Workspace:\*\*\s*`([^`]+)`/);
+		return match ? match[1].trim() : '';
+	} catch {
+		return '';
+	}
+}
+
+function resolveWorkspaces(options = {}) {
+	const seen = new Set();
+	const roots = [];
+	const add = (value) => {
+		const trimmed = String(value || '').trim();
+		if (!trimmed) return;
+		const resolved = path.resolve(trimmed);
+		if (seen.has(resolved)) return;
+		seen.add(resolved);
+		roots.push(resolved);
+	};
+
+	for (const entry of (process.env.LIVE_FLEET_WORKSPACES || '').split(',')) {
+		add(entry);
+	}
+	add(options.workspaceRoot);
+	add(process.env.AGENTIDE_WORKSPACE_ROOT);
+	add(parsePathsMdWorkspace(path.join(getAgentHome(), 'paths.md')));
+	add(parsePathsMdWorkspace(path.join(process.cwd(), BRAND_DIR, 'paths.md')));
+	add(process.cwd());
+
+	return roots.filter((root) => {
+		try {
+			return fs.statSync(root).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+}
+
+function persistKnownWorkspaces(exportDir, workspaces) {
+	if (!exportDir) return;
+	const knownPath = path.join(exportDir, KNOWN_WORKSPACES_FILE);
+	let existing = { workspaces: [] };
+	try {
+		existing = JSON.parse(fs.readFileSync(knownPath, 'utf8'));
+	} catch { /* first run */ }
+	const merged = new Set([
+		...(Array.isArray(existing.workspaces) ? existing.workspaces : []),
+		...workspaces,
+	]);
+	const nextWorkspaces = Array.from(merged).sort();
+	const prevWorkspaces = Array.isArray(existing.workspaces) ? [...existing.workspaces].sort() : [];
+	if (nextWorkspaces.length === prevWorkspaces.length
+		&& nextWorkspaces.every((ws, i) => ws === prevWorkspaces[i])) {
+		return;
+	}
+	fs.mkdirSync(exportDir, { recursive: true });
+	fs.writeFileSync(knownPath, `${JSON.stringify({
+		updatedAt: new Date().toISOString(),
+		workspaces: nextWorkspaces,
+	}, null, 2)}\n`, 'utf8');
+}
+
+function readWorkflowFile(filePath, workspaceRoot, kind) {
+	try {
+		const raw = fs.readFileSync(filePath, 'utf8');
+		const doc = JSON.parse(raw);
+		if (!doc || typeof doc !== 'object') return null;
+		const stat = fs.statSync(filePath);
+		const base = path.basename(filePath, '.json');
+		return {
+			...doc,
+			kind: doc.kind || kind,
+			runId: doc.runId || base.split('-').slice(-1)[0],
+			_file: filePath,
+			_workspaceRoot: workspaceRoot,
+			_mtimeMs: stat.mtimeMs,
+		};
+	} catch {
+		return null;
+	}
+}
+
+function scanDir(dir, workspaceRoot, kind) {
+	const workflows = [];
+	if (!dir) return workflows;
+	try {
+		for (const file of fs.readdirSync(dir)) {
+			if (!file.endsWith('.json') || file.startsWith('.')) continue;
+			const filePath = path.join(dir, file);
+			const doc = readWorkflowFile(filePath, workspaceRoot, kind);
+			if (doc) workflows.push(doc);
+		}
+	} catch { /* missing */ }
+	return workflows;
+}
+
+function scanWorkspace(workspaceRoot) {
+	const root = path.join(workspaceRoot, BRAND_DIR, WORKFLOWS_DIRNAME);
+	const active = scanDir(root, workspaceRoot, 'active');
+	const history = scanDir(path.join(root, HISTORY_DIRNAME), workspaceRoot, 'history');
+	return [...active, ...history];
+}
+
+function detectCliActive() {
+	try {
+		const cmd = process.platform === 'win32' ? 'wmic process get commandline' : 'ps -ax -o command=';
+		const out = execSync(cmd, { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+		return /\bagenthippo\b/i.test(out) && /\b(ask|chat)\b/i.test(out);
+	} catch {
+		return false;
+	}
+}
+
+function normalizeWorkflow(wf) {
+	return {
+		workflowId: wf.workflowId,
+		runId: wf.runId || '',
+		title: wf.title || wf.workflowId,
+		subtitle: wf.subtitle || '',
+		status: wf.status || 'in_progress',
+		kind: wf.kind || 'active',
+		startedAt: wf.startedAt || '',
+		updatedAt: wf.updatedAt || '',
+		finishedAt: wf.finishedAt || '',
+		archivedAt: wf.archivedAt || '',
+		artifact: wf.artifact || wf._file || '',
+		orchestrator: wf.orchestrator || {},
+		steps: (Array.isArray(wf.steps) ? wf.steps : []).slice().sort((a, b) => (a.step || 0) - (b.step || 0)),
+		workspaceRoot: wf._workspaceRoot || '',
+		sourcePath: wf._file || '',
+	};
+}
+
+function workflowKey(wf) {
+	return `${wf.workflowId}::${wf.runId || wf.startedAt || wf.updatedAt}`;
+}
+
+function buildTotals(running, finished, history) {
+	let stepsTotal = 0;
+	let stepsDone = 0;
+	let stepsActive = 0;
+	for (const wf of [...running, ...finished, ...history]) {
+		const steps = wf.steps || [];
+		stepsTotal += steps.length;
+		stepsDone += steps.filter((s) => s.status === 'done').length;
+		stepsActive += steps.filter((s) => s.status === 'in_progress').length;
+	}
+	return {
+		workflows: running.length + finished.length + history.length,
+		running: running.length,
+		finished: history.length,
+		history: history.length,
+		inProgress: running.length,
+		done: history.length + running.filter((w) => w.status === 'done').length,
+		stepsTotal,
+		stepsDone,
+		stepsActive,
+	};
+}
+
+function collect(options = {}) {
+	const exportDir = options.exportDir || '';
+	const workspaces = resolveWorkspaces(options);
+	if (exportDir) persistKnownWorkspaces(exportDir, workspaces);
+
+	const all = [];
+	for (const root of workspaces) {
+		all.push(...scanWorkspace(root));
+	}
+
+	const byKey = new Map();
+	for (const wf of all) {
+		const normalized = normalizeWorkflow(wf);
+		const key = workflowKey(normalized);
+		const existing = byKey.get(key);
+		if (!existing || (wf._mtimeMs || 0) >= (existing._mtimeMs || 0)) {
+			byKey.set(key, { ...normalized, _mtimeMs: wf._mtimeMs });
+		}
+	}
+
+	const workflows = Array.from(byKey.values()).map(({ _mtimeMs, ...rest }) => rest);
+	const running = workflows.filter((w) => w.kind === 'active' && w.status === 'in_progress')
+		.sort((a, b) => Date.parse(b.updatedAt || '') - Date.parse(a.updatedAt || ''));
+	const finished = workflows.filter((w) => w.kind === 'active' && w.status === 'done')
+		.sort((a, b) => Date.parse(b.finishedAt || b.updatedAt || '') - Date.parse(a.finishedAt || a.updatedAt || ''));
+	const history = workflows.filter((w) => w.kind === 'history')
+		.sort((a, b) => Date.parse(b.archivedAt || b.finishedAt || b.updatedAt || '') - Date.parse(a.archivedAt || a.finishedAt || a.updatedAt || ''));
+
+	return {
+		generatedAt: new Date().toISOString(),
+		source: resolveViewId(),
+		totals: buildTotals(running, finished, history),
+		running,
+		finished,
+		history,
+		workflows: [...running, ...finished, ...history],
+		diagnostics: {
+			workspaces,
+			cliActive: detectCliActive(),
+			workflowCount: workflows.length,
+		},
+	};
+}
+
+/** Compare export bodies ignoring generatedAt and volatile CLI hints. */
+function stableExportString(payload) {
+	const clone = { ...payload };
+	delete clone.generatedAt;
+	if (clone.diagnostics && typeof clone.diagnostics === 'object') {
+		const diag = { ...clone.diagnostics };
+		delete diag.cliActive;
+		clone.diagnostics = diag;
+	}
+	return JSON.stringify(clone);
+}
+
+function writeSnapshot(exportDir, payload) {
+	fs.mkdirSync(exportDir, { recursive: true });
+	const exportPath = path.join(exportDir, resolveSnapshotFile());
+	let existingRaw = '';
+	let existingGeneratedAt = '';
+	try {
+		existingRaw = fs.readFileSync(exportPath, 'utf8');
+		const existing = JSON.parse(existingRaw);
+		existingGeneratedAt = existing.generatedAt || '';
+		if (stableExportString(existing) === stableExportString(payload)) {
+			return { exportPath, changed: false };
+		}
+	} catch { /* first write */ }
+
+	const toWrite = {
+		...payload,
+		generatedAt: new Date().toISOString(),
+	};
+	const body = `${JSON.stringify(toWrite, null, 2)}\n`;
+	if (existingRaw === body) {
+		return { exportPath, changed: false };
+	}
+	const tmp = `${exportPath}.${process.pid}.tmp`;
+	fs.writeFileSync(tmp, body, 'utf8');
+	fs.renameSync(tmp, exportPath);
+	return { exportPath, changed: true };
+}
+
+function main() {
+	const exportDir = process.env.LIVE_FLEET_EXPORT_DIR
+		? path.resolve(process.env.LIVE_FLEET_EXPORT_DIR)
+		: path.join(__dirname, '..', 'exports');
+	const payload = collect({ exportDir, workspaceRoot: process.env.AGENTIDE_WORKSPACE_ROOT });
+	const { exportPath, changed } = writeSnapshot(exportDir, payload);
+	console.log(`[workflows-collector] ${payload.totals.running} running, ${payload.totals.finished} finished, ${payload.totals.history} history → ${exportPath}${changed ? '' : ' (unchanged)'}`);
+}
+
+module.exports = {
+	get SNAPSHOT_FILE() {
+		return resolveSnapshotFile();
+	},
+	get SOURCE_ID() {
+		return resolveViewId();
+	},
+	resolveViewId,
+	resolveSnapshotFile,
+	collect,
+	writeSnapshot,
+	resolveWorkspaces,
+	getAgentHome,
+	WORKFLOWS_DIRNAME,
+	HISTORY_DIRNAME,
+	persistKnownWorkspaces,
+};
+
+if (require.main === module) {
+	main();
+}

package/out/scripts/analytics/workflows-daemon.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/* Workflows daemon — watches fleet-workflows + history; refreshes exports/<viewId>.json */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const {
+	collect,
+	writeSnapshot,
+	resolveViewId,
+	getAgentHome,
+	WORKFLOWS_DIRNAME,
+	HISTORY_DIRNAME,
+	persistKnownWorkspaces,
+} = require('./workflows-collector.cjs');
+
+const BRAND_DIR = '.agent-hippo';
+const DEBOUNCE_MS = 350;
+const POLL_MS = 2500;
+
+function resolveExportDir() {
+	if (process.env.LIVE_FLEET_EXPORT_DIR) {
+		return path.resolve(process.env.LIVE_FLEET_EXPORT_DIR);
+	}
+	return path.join(__dirname, '..', 'exports');
+}
+
+function resolveDaemonPidFile(exportDir) {
+	return path.join(exportDir, `${resolveViewId()}-daemon.pid`);
+}
+
+function isPidAlive(pid) {
+	if (!Number.isFinite(pid) || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function readPidFile(pidFile) {
+	try {
+		return parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+	} catch {
+		return NaN;
+	}
+}
+
+function writeDaemonPidFile(pidFile) {
+	fs.writeFileSync(pidFile, `${process.pid}\n`, 'utf8');
+}
+
+function removeDaemonPidFile(pidFile) {
+	try {
+		fs.unlinkSync(pidFile);
+	} catch {
+		// already removed
+	}
+}
+
+function resolveWatchRoots(exportDir) {
+	const agentHome = getAgentHome();
+	const roots = [
+		path.join(agentHome, 'analytics', 'sessions'),
+	];
+
+	const workspaces = new Set();
+	for (const entry of (process.env.LIVE_FLEET_WORKSPACES || '').split(',')) {
+		const t = entry.trim();
+		if (t) workspaces.add(path.resolve(t));
+	}
+	const fromEnv = (process.env.AGENTIDE_WORKSPACE_ROOT || '').trim();
+	if (fromEnv) workspaces.add(path.resolve(fromEnv));
+
+	try {
+		const knownPath = path.join(exportDir, 'known-workspaces.json');
+		const known = JSON.parse(fs.readFileSync(knownPath, 'utf8'));
+		if (Array.isArray(known.workspaces)) {
+			for (const ws of known.workspaces) workspaces.add(path.resolve(ws));
+		}
+	} catch { /* first run */ }
+
+	for (const workspaceRoot of workspaces) {
+		roots.push(path.join(workspaceRoot, BRAND_DIR, WORKFLOWS_DIRNAME));
+		roots.push(path.join(workspaceRoot, BRAND_DIR, WORKFLOWS_DIRNAME, HISTORY_DIRNAME));
+	}
+
+	return roots.filter((root) => {
+		try {
+			fs.mkdirSync(root, { recursive: true });
+			return true;
+		} catch {
+			return false;
+		}
+	});
+}
+
+function refresh(exportDir) {
+	const payload = collect({
+		exportDir,
+		workspaceRoot: process.env.AGENTIDE_WORKSPACE_ROOT,
+	});
+	const { changed } = writeSnapshot(exportDir, payload);
+	return { payload, changed };
+}
+
+function main() {
+	const exportDir = resolveExportDir();
+	fs.mkdirSync(exportDir, { recursive: true });
+
+	const pidFile = resolveDaemonPidFile(exportDir);
+	const existingPid = readPidFile(pidFile);
+	if (isPidAlive(existingPid) && existingPid !== process.pid) {
+		process.stderr.write(
+			`[workflows-daemon] already running (pid=${existingPid}); pid file: ${pidFile}\n`,
+		);
+		process.exit(1);
+	}
+	writeDaemonPidFile(pidFile);
+	process.stdout.write(`[workflows-daemon] pid file: ${pidFile} (pid=${process.pid})\n`);
+
+	let debounceTimer;
+	let running = false;
+
+	const run = () => {
+		if (running) return;
+		running = true;
+		try {
+			const { payload, changed } = refresh(exportDir);
+			if (!changed) {
+				running = false;
+				return;
+			}
+			const t = payload.totals || {};
+			process.stdout.write(
+				`[workflows-daemon] ${new Date().toISOString()} `
+				+ `run=${t.running || 0} done=${t.finished || 0} hist=${t.history || 0}`
+				+ (payload.diagnostics?.cliActive ? ' cli' : '') + '\n',
+			);
+		} catch (err) {
+			process.stderr.write(`[workflows-daemon] ${err instanceof Error ? err.message : String(err)}\n`);
+		} finally {
+			running = false;
+		}
+	};
+
+	const schedule = () => {
+		clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(run, DEBOUNCE_MS);
+	};
+
+	const watchers = [];
+	for (const root of resolveWatchRoots(exportDir)) {
+		try {
+			const watcher = fs.watch(root, { recursive: true }, schedule);
+			watchers.push(watcher);
+			process.stdout.write(`[workflows-daemon] watching ${root}\n`);
+		} catch (err) {
+			process.stderr.write(`[workflows-daemon] skip ${root}: ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+	}
+
+	run();
+	const interval = setInterval(run, POLL_MS);
+
+	const shutdown = () => {
+		clearInterval(interval);
+		clearTimeout(debounceTimer);
+		for (const w of watchers) w.close();
+		removeDaemonPidFile(pidFile);
+		process.exit(0);
+	};
+	process.on('SIGINT', shutdown);
+	process.on('SIGTERM', shutdown);
+	process.on('exit', () => {
+		removeDaemonPidFile(pidFile);
+	});
+}
+
+main();