91 lines
9.2 KiB
TypeScript
91 lines
9.2 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { afterConfigurationIntentCommit } from "./fixtures/configuration-audit-commit.js"
|
|
import { randomUUID } from "node:crypto"
|
|
import { createServer } from "node:http"
|
|
import { setTimeout as delay } from "node:timers/promises"
|
|
import Fastify from "fastify"
|
|
import { mcpConnectionCreateSchema } from "@mmapp/contracts/mcp"
|
|
import type { AuthUser } from "../lib/permissions.js"
|
|
import { pool } from "../db/index.js"
|
|
import { createMcpConnection, authenticateMcpToken, setConnectionStatus } from "../modules/mcp/store.js"
|
|
import { invokeMcpTool, approvePlan, applyPlan, loadPlan } from "../modules/mcp/runtime.js"
|
|
import { encryptSecret, decryptSecret } from "../modules/mcp/security.js"
|
|
import { findMcpService } from "../modules/mcp/service-registry.js"
|
|
import { TELEGRAM_SECRET_PURPOSE } from "../modules/mcp/telegram-settings-actions.js"
|
|
import alertsRoutes from "../routes/alerts.js"
|
|
|
|
export async function verifyMcpTelegramTest(actor:AuthUser){
|
|
const owner={...actor,id:"telegram-test-owner",permissions:[...actor.permissions,"mm:alerts:write"]}
|
|
const saved=(await pool.query("SELECT * FROM alert_telegram_settings WHERE id=1")).rows[0]
|
|
const ids=(await pool.query<{id:number}>("SELECT id FROM servers ORDER BY id")).rows.map(r=>r.id)
|
|
const issued=await createMcpConnection(mcpConnectionCreateSchema.parse({name:"Telegram test",mode:"approval",expiresAt:new Date(Date.now()+1800000).toISOString(),permissions:["mm:alerts:write"],scope:{allowGlobal:true,serverIds:ids,operationIds:["alerts.telegram.test"]},limits:{callsPerMinute:120,mutationsPerHour:100}}),owner)
|
|
const principal=await authenticateMcpToken(issued.token),secretRef=randomUUID(),protection=randomUUID()
|
|
const token="123456:NEVER_TELEGRAM_TEST_TOKEN",override="654321:NEVER_TELEGRAM_OVERRIDE"
|
|
const originalFetch=globalThis.fetch
|
|
let mode="normal",calls=0
|
|
const payloads:Record<string,unknown>[]=[],urls:string[]=[]
|
|
const server=createServer((req,res)=>{
|
|
let body="";req.on("data",chunk=>{body+=chunk});req.on("end",()=>{
|
|
calls++;payloads.push(JSON.parse(body));res.setHeader("content-type","application/json")
|
|
if(mode==="lost"){req.socket.destroy();return}
|
|
if(mode==="rejected"){res.statusCode=429;res.end(JSON.stringify({ok:false,error_code:429,description:token}));return}
|
|
if(mode==="malformed"){res.end("{}");return}
|
|
if(mode==="oversized"){res.end('{'+" ".repeat(65537)+'"ok":true}');return}
|
|
res.end('{"ok":true}')
|
|
})
|
|
})
|
|
await new Promise<void>(resolve=>server.listen(0,"127.0.0.1",resolve))
|
|
const local=`http://127.0.0.1:${(server.address()as{port:number}).port}/send`
|
|
globalThis.fetch=(async(url,init)=>{
|
|
const target=String(url);if(!target.startsWith("https://api.telegram.org/bot")||!target.endsWith("/sendMessage"))throw Error("Unexpected network request in isolated Telegram fixture")
|
|
urls.push(target);assert.equal(init?.redirect,"error");return originalFetch(local,init)
|
|
}) as typeof fetch
|
|
const rest=Fastify();await rest.register(alertsRoutes,{prefix:"/api"})
|
|
const prepare=(input:Record<string,unknown>={})=>invokeMcpTool(principal,"mm_alerts_telegram_test_plan",input) as Promise<{planId:string;state:string}>
|
|
const wait=async(id:string)=>{for(let i=0;i<600;i++){const row=(await pool.query("SELECT state,error_code,verification FROM mcp_operations WHERE id=$1",[id])).rows[0];if(!["pending","running"].includes(row.state))return row;await delay(25)}throw Error("Telegram test still live; do not replay")}
|
|
const apply=async(input:Record<string,unknown>={})=>{const plan=await prepare(input);assert.equal(plan.state,"awaiting-approval");assert.ok(!JSON.stringify(plan).includes(token));assert.ok(!JSON.stringify(plan).includes(override));await approvePlan(plan.planId,owner,true);const key=randomUUID(),op=await applyPlan(principal,plan.planId,key);return {plan,key,op,...await wait(op.id)}}
|
|
try{
|
|
await pool.query("INSERT INTO alert_telegram_settings(id,bot_token,chat_id,message_thread_id) VALUES(1,$1,'fixture-chat',42) ON CONFLICT(id) DO UPDATE SET bot_token=$1,chat_id='fixture-chat',message_thread_id=42",[token])
|
|
await pool.query("INSERT INTO mcp_secrets(id,purpose,server_id,ciphertext,created_by) VALUES($1,$2,NULL,$3,$4)",[secretRef,TELEGRAM_SECRET_PURPOSE,await encryptSecret(override),owner.id])
|
|
const unapproved=await prepare();await assert.rejects(applyPlan(principal,unapproved.planId,randomUUID()));assert.equal(calls,0)
|
|
const sealed=(await loadPlan(unapproved.planId)).evidence.sealed
|
|
const input=JSON.parse(await decryptSecret(sealed)).steps[0].input
|
|
await assert.rejects(findMcpService("alerts.telegram.test")!.execute({...input,messagePreview:"different text"}),/preview/)
|
|
await assert.rejects(findMcpService("alerts.telegram.test")!.execute({...input,destination:{chatId:"different",messageThreadId:42}}),/preview/)
|
|
assert.equal(calls,0)
|
|
console.log("✓ Telegram preview fence: text/recipient mismatch refuses before HTTP dispatch")
|
|
const preview={name:"Fixture alert",targets:["fixture-router"],conditionLine:"loss > 0",severity:"warning",cooldown:"5м"}
|
|
let result=await apply({secretRef,chatId:"override-chat",messageThreadId:9,rulePreview:preview})
|
|
assert.equal(result.state,"applied");assert.equal(result.verification,"inconclusive");assert.equal(calls,1);assert.ok(urls[0].includes(encodeURIComponent(override)))
|
|
const sent=payloads[0];assert.equal(sent.chat_id,"override-chat");assert.equal(sent.message_thread_id,9)
|
|
await applyPlan(principal,result.plan.planId,result.key);assert.equal(calls,1)
|
|
const response=await rest.inject({method:"POST",url:"/api/alerts/telegram/test",payload:{token:override,chatId:"override-chat",messageThreadId:9,rulePreview:preview}})
|
|
assert.equal(response.statusCode,200,response.body);assert.deepEqual(payloads[1],sent)
|
|
assert.equal((await pool.query("SELECT bot_token FROM alert_telegram_settings WHERE id=1")).rows[0].bot_token,token)
|
|
for(const fault of ["rejected","lost","malformed","oversized"]){
|
|
mode=fault;const before:number=calls;result=await apply();assert.equal(calls,before+1);assert.equal(result.state,fault==="rejected"?"partial":"unknown")
|
|
if(fault==="rejected"){const receipt=(await pool.query("SELECT result FROM mcp_operation_steps WHERE operation_id=$1",[result.op.id])).rows[0].result;assert.equal(receipt.outcome,"rejected");assert.equal(receipt.providerAccepted,false)}
|
|
await applyPlan(principal,result.plan.planId,result.key);assert.equal(calls,before+1)
|
|
}
|
|
mode="normal"
|
|
const stale=await prepare();await approvePlan(stale.planId,owner,true);await pool.query("UPDATE alert_telegram_settings SET chat_id='changed' WHERE id=1")
|
|
const beforeStale=calls;assert.equal((await wait((await applyPlan(principal,stale.planId,randomUUID())).id)).state,"rejected");assert.equal(calls,beforeStale)
|
|
await pool.query("UPDATE alert_telegram_settings SET chat_id='fixture-chat' WHERE id=1")
|
|
await pool.query("INSERT INTO mcp_protections(id,object_ref,created_by) VALUES($1,$2::jsonb,$3)",[protection,JSON.stringify({kind:"alerts-telegram-test",id:"1",protection:"deny"}),owner.id])
|
|
await assert.rejects(prepare());assert.equal((await rest.inject({method:"POST",url:"/api/alerts/telegram/test",payload:{}})).statusCode,409);assert.equal(calls,beforeStale)
|
|
await pool.query("DELETE FROM mcp_protections WHERE id=$1",[protection])
|
|
for(const input of [{token:token},{settings:{}},{messageThreadId:0},{rulePreview:{...preview,name:"x".repeat(201)}}])await assert.rejects(prepare(input))
|
|
const cancelled=new AbortController();cancelled.abort();await assert.rejects(invokeMcpTool(principal,"mm_alerts_telegram_test_plan",{},cancelled.signal))
|
|
const late=await prepare();await approvePlan(late.planId,owner,true)
|
|
const drift=afterConfigurationIntentCommit("alerts-telegram-test",()=>pool.query("UPDATE alert_telegram_settings SET chat_id='late-drift' WHERE id=1"))
|
|
try{const before=calls;assert.equal((await wait((await applyPlan(principal,late.planId,randomUUID())).id)).state,"unknown");assert(drift.fired());assert.equal(calls,before)}finally{drift.restore()}
|
|
const audit=await pool.query("SELECT payload FROM mcp_audit WHERE connection_id=$1",[issued.connection.id]);assert.ok(!JSON.stringify(audit.rows).includes(token));assert.ok(!JSON.stringify(audit.rows).includes(override))
|
|
await setConnectionStatus(issued.connection.id,"paused",owner);await assert.rejects(prepare())
|
|
console.log("✓ Telegram test plan: human-only, shared REST payload, exact one local HTTP POST, stored/reference overrides, accepted acknowledgement not delivery, explicit provider rejection partial, transport/malformed/oversized unknown, no replay, stale/late source and REST protections; no real Telegram network")
|
|
}finally{
|
|
globalThis.fetch=originalFetch;await rest.close();await new Promise<void>(resolve=>server.close(()=>resolve()))
|
|
await setConnectionStatus(issued.connection.id,"paused",owner);await pool.query("DELETE FROM mcp_secrets WHERE id=$1",[secretRef]);await pool.query("DELETE FROM mcp_protections WHERE id=$1",[protection])
|
|
if(saved)await pool.query("UPDATE alert_telegram_settings SET bot_token=$1,chat_id=$2,message_thread_id=$3,updated_at=$4 WHERE id=1",[saved.bot_token,saved.chat_id,saved.message_thread_id,saved.updated_at]);else await pool.query("DELETE FROM alert_telegram_settings WHERE id=1")
|
|
}
|
|
}
|