' + new Date().toISOString() + '');
return lines.join('\n');
}
function escapeHtml(s) {
return String(s == null ? '' : s)
.replace(/&/g, '&').replace(//g, '>');
}
// ---------- Telegram config detection ----------
function telegramConfigured() {
try {
if (typeof TelegramAlert === 'undefined') return false;
if (typeof TelegramAlert.isConfigured === 'function') return !!TelegramAlert.isConfigured();
// Fallback: check localStorage keys some integrations commonly use.
const tok = localStorage.getItem('tg_bot_token') || localStorage.getItem('telegram_bot_token');
const chat = localStorage.getItem('tg_chat_id') || localStorage.getItem('telegram_chat_id');
return !!(tok && chat);
} catch (_) { return false; }
}
// ---------- core manager ----------
const Manager = {
_timer: null,
_running: false,
_intervalMs: 60_000,
_lastTickAt: null,
_lastState: null,
_listeners: new Set(),
getRules() { return loadRules(); },
setRules(rules) { saveRules(rules); this._emit(); },
getState() { return loadState(); },
getLastSnapshot() { return this._lastState; },
getLastTickAt() { return this._lastTickAt; },
telegramConfigured() { return telegramConfigured(); },
onChange(cb) {
this._listeners.add(cb);
return () => this._listeners.delete(cb);
},
_emit() {
this._listeners.forEach(cb => { try { cb(); } catch (_) {} });
},
addRule(partial) {
const rules = loadRules();
const rule = Object.assign({
id: mkId(),
type: 'BTC_ABOVE',
threshold: 0,
cooldownMin: DEFAULT_COOLDOWN_MIN,
enabled: true,
note: '',
}, partial || {});
rules.push(rule);
saveRules(rules);
this._emit();
return rule;
},
updateRule(id, patch) {
const rules = loadRules().map(r => r.id === id ? Object.assign({}, r, patch) : r);
saveRules(rules);
this._emit();
},
deleteRule(id) {
const rules = loadRules().filter(r => r.id !== id);
saveRules(rules);
const st = loadState();
delete st[id];
saveState(st);
this._emit();
},
toggleRule(id) {
const rules = loadRules().map(r => r.id === id ? Object.assign({}, r, { enabled: !r.enabled }) : r);
saveRules(rules);
this._emit();
},
async testSend() {
if (typeof TelegramAlert === 'undefined') return { ok: false, error: 'TelegramAlert missing' };
const ts = new Date().toISOString();
const msg = `TR test alert\nTelegram connection OK.\n${ts}`;
return TelegramAlert.send(msg, { parseMode: 'HTML' });
},
async testSendRule(id) {
const rule = loadRules().find(r => r.id === id);
if (!rule) return { ok: false, error: 'rule not found' };
if (typeof TelegramAlert === 'undefined') return { ok: false, error: 'TelegramAlert missing' };
const state = this._lastState || await collectState();
const reason = `[TEST] ${labelForType(rule.type)} — threshold ${rule.threshold}`;
const msg = formatMessage(rule, reason, state);
return TelegramAlert.send(msg, { parseMode: 'HTML' });
},
async tick() {
const state = await collectState();
this._lastState = state;
this._lastTickAt = Date.now();
const rules = loadRules();
const runState = loadState();
const now = Date.now();
let fired = 0;
for (const rule of rules) {
if (!rule.enabled) continue;
const reason = evaluateRule(rule, state);
if (!reason) continue;
const cooldownMs = Math.max(0, Number(rule.cooldownMin) || DEFAULT_COOLDOWN_MIN) * 60_000;
const last = runState[rule.id] || 0;
if (now - last < cooldownMs) continue;
// Fire — only call Telegram if configured; otherwise mark state so we
// don't hammer the check on every tick.
if (typeof TelegramAlert !== 'undefined') {
try {
const msg = formatMessage(rule, reason, state);
await TelegramAlert.send(msg, { parseMode: 'HTML' });
} catch (_) { /* silent */ }
}
runState[rule.id] = now;
fired++;
}
saveState(runState);
this._emit();
return { fired, state };
},
start(intervalMs) {
if (this._running) return;
if (intervalMs && intervalMs > 5_000) this._intervalMs = intervalMs;
this._running = true;
// First tick after a small delay so the engine has time to boot.
setTimeout(() => { this.tick(); }, 2_000);
this._timer = setInterval(() => { this.tick(); }, this._intervalMs);
},
stop() {
this._running = false;
if (this._timer) { clearInterval(this._timer); this._timer = null; }
},
isRunning() { return this._running; },
};
window.TRAlertsManager = Manager;
// ---------- global open trigger ----------
window.openTRAlerts = function openTRAlerts() {
try { window.dispatchEvent(new CustomEvent('tr:open-alerts')); } catch (_) {}
};
// ---------- React panel ----------
function TRAlertsPanel({ open, onClose }) {
const T = {
ink000: '#07090C', ink100: '#0B0E13', ink200: '#10141B', ink300: '#171C24',
edge: 'rgba(255,255,255,0.06)', edgeHi: 'rgba(255,255,255,0.10)',
text: '#ffffff', textMid: 'rgba(180,188,200,0.75)', textDim: 'rgba(130,138,150,0.55)',
signal: '#c9a227', signalSoft: 'rgba(201,162,39,0.12)',
bull: '#6FCF8E', bear: '#D96B6B', amber: '#E8A94B',
mono: '"JetBrains Mono", ui-monospace, "SF Mono", Menlo, Consolas, monospace',
};
const [rules, setRules] = React.useState(Manager.getRules());
const [runState, setRunState] = React.useState(Manager.getState());
const [snapshot, setSnapshot] = React.useState(Manager.getLastSnapshot());
const [testStatus, setTestStatus] = React.useState(null);
const [perRuleTest, setPerRuleTest] = React.useState({}); // { [ruleId]: 'sending'|'ok'|'err' }
const [newType, setNewType] = React.useState('BTC_ABOVE');
const [newThreshold, setNewThreshold] = React.useState('');
const [newCooldown, setNewCooldown] = React.useState(60);
const [newNote, setNewNote] = React.useState('');
const [tgConfigured, setTgConfigured] = React.useState(Manager.telegramConfigured());
React.useEffect(() => {
const off = Manager.onChange(() => {
setRules(Manager.getRules());
setRunState(Manager.getState());
setSnapshot(Manager.getLastSnapshot());
setTgConfigured(Manager.telegramConfigured());
});
const int = setInterval(() => setTgConfigured(Manager.telegramConfigured()), 4000);
return () => { off(); clearInterval(int); };
}, []);
if (!open) return null;
const inputStyle = {
padding: '6px 10px', fontFamily: T.mono, fontSize: 11,
background: T.ink000, border: `1px solid ${T.edge}`, color: T.text,
borderRadius: 6, outline: 'none', width: '100%',
};
const labelStyle = {
fontSize: 9, letterSpacing: 0.8, color: T.textDim,
textTransform: 'uppercase', fontWeight: 600, marginBottom: 4,
};
function handleAdd() {
const threshold = parseFloat(newThreshold);
if (newType !== 'CONSENSUS_DIVERGENT' && !isFinite(threshold)) return;
Manager.addRule({
type: newType,
threshold: isFinite(threshold) ? threshold : 0,
cooldownMin: Math.max(1, Number(newCooldown) || 60),
enabled: true,
note: newNote || '',
});
setNewThreshold('');
setNewNote('');
}
async function handleTest() {
setTestStatus('sending');
const res = await Manager.testSend();
setTestStatus(res && res.ok ? 'ok' : 'err');
setTimeout(() => setTestStatus(null), 3500);
}
async function handleTestRule(id) {
setPerRuleTest(s => Object.assign({}, s, { [id]: 'sending' }));
const res = await Manager.testSendRule(id);
setPerRuleTest(s => Object.assign({}, s, { [id]: res && res.ok ? 'ok' : 'err' }));
setTimeout(() => {
setPerRuleTest(s => {
const cp = Object.assign({}, s); delete cp[id]; return cp;
});
}, 3500);
}
function fmtLast(ts) {
if (!ts) return '—';
const d = Date.now() - ts;
if (d < 60_000) return Math.round(d / 1000) + 's ago';
if (d < 3_600_000) return Math.round(d / 60_000) + 'm ago';
if (d < 86_400_000) return Math.round(d / 3_600_000) + 'h ago';
return Math.round(d / 86_400_000) + 'd ago';
}
// Group rules by type.group
const groupOrder = ['Crypto', 'Equities', 'Sentiment', 'Geopolitics', 'Flow', 'Other'];
const grouped = {};
for (const r of rules) {
const g = groupForType(r.type);
if (!grouped[g]) grouped[g] = [];
grouped[g].push(r);
}
const groupKeys = groupOrder.filter(g => grouped[g] && grouped[g].length);
// Hero banner — telegram status
const tgBadge = tgConfigured
? { color: T.bull, bg: 'rgba(111,207,142,0.10)', border: 'rgba(111,207,142,0.4)', label: 'TELEGRAM CONNECTED' }
: { color: T.amber, bg: 'rgba(232,169,75,0.10)', border: 'rgba(232,169,75,0.4)', label: 'TELEGRAM NOT CONFIGURED' };
return (
/newbot, copy the token.