@tritard/waterbrother 0.16.100 → 0.16.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.100",
+  "version": "0.16.101",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -3154,7 +3154,7 @@ async function dequeueTelegramBridgeRequest({ cwd }) {
   return next;
 }
 
-async function deliverTelegramBridgeReply(request, { sessionId, content = "", error = "" }) {
+async function deliverTelegramBridgeReply(request, { sessionId, content = "", error = "", meta = {} }) {
   const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
   const replies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies : [];
   replies.push({
@@ -3163,6 +3163,7 @@ async function deliverTelegramBridgeReply(request, { sessionId, content = "", er
     sessionId: String(sessionId || "").trim(),
     content: String(content || "").trim(),
     error: String(error || "").trim(),
+    meta: meta && typeof meta === "object" ? { ...meta } : {},
     completedAt: new Date().toISOString(),
     source: "tui"
   });
@@ -3187,6 +3188,92 @@ function formatTelegramRemoteActor(request = {}) {
   return username || userId || "telegram";
 }
 
+async function planTelegramVerificationCommands(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  let scripts = {};
+  try {
+    const raw = await fs.readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    scripts = parsed?.scripts && typeof parsed.scripts === "object" ? parsed.scripts : {};
+  } catch {}
+  const commands = [];
+  if (scripts.check) commands.push(["npm", ["run", "check"], "npm run check"]);
+  if (scripts.test) commands.push(["npm", ["test"], "npm test"]);
+  if (scripts.build) commands.push(["npm", ["run", "build"], "npm run build"]);
+  if (!commands.length) {
+    throw new Error("No verification commands are available here. Expected package.json scripts like check, test, or build.");
+  }
+  return commands;
+}
+
+function formatTelegramVerificationSummary(result = {}) {
+  const lines = [
+    "Verification result",
+    `outcome: ${String(result.outcome || "failed").trim() || "failed"}`
+  ];
+  if (Array.isArray(result.commands) && result.commands.length) {
+    lines.push("commands:");
+    for (const command of result.commands) {
+      lines.push(`• ${String(command || "").trim()}`);
+    }
+  }
+  if (result.summary) {
+    lines.push("Summary");
+    lines.push(String(result.summary || "").trim());
+  }
+  if (Array.isArray(result.logs) && result.logs.length) {
+    lines.push("Top errors");
+    for (const line of result.logs.slice(0, 6)) {
+      lines.push(`• ${String(line || "").trim()}`);
+    }
+  }
+  return lines.filter(Boolean).join("\n");
+}
+
+async function runTelegramLocalVerification(cwd) {
+  const planned = await planTelegramVerificationCommands(cwd);
+  const commands = [];
+  const startedAt = new Date().toISOString();
+  const logs = [];
+  let passedCount = 0;
+  for (const [bin, args, label] of planned) {
+    commands.push(label);
+    try {
+      await execFileAsync(bin, args, {
+        cwd,
+        env: { ...process.env },
+        maxBuffer: 8 * 1024 * 1024,
+        timeout: 10 * 60 * 1000
+      });
+      passedCount += 1;
+    } catch (error) {
+      const combined = `${String(error?.stderr || "")}\n${String(error?.stdout || "")}`.trim();
+      const extracted = combined
+        .split("\n")
+        .map((line) => String(line || "").trim())
+        .filter(Boolean)
+        .slice(0, 6);
+      logs.push(...extracted);
+      return {
+        outcome: error?.killed || error?.signal === "SIGTERM" ? "timeout" : (passedCount > 0 ? "partial" : "failed"),
+        summary: `${label} failed${passedCount > 0 ? ` after ${passedCount} passing check${passedCount === 1 ? "" : "s"}` : ""}.`,
+        commands,
+        startedAt,
+        completedAt: new Date().toISOString(),
+        logs
+      };
+    }
+  }
+  return {
+    outcome: "passed",
+    summary: `${commands.length} verification command${commands.length === 1 ? "" : "s"} passed.`,
+    commands,
+    startedAt,
+    completedAt: new Date().toISOString(),
+    logs
+  };
+}
+
 async function chooseFromInteractiveMenu({ title, options, defaultIndex = 0 }) {
   if (!process.stdin.isTTY || !process.stdout.isTTY || options.length === 0) {
     return options[Math.max(0, Math.min(defaultIndex, options.length - 1))] || null;
@@ -7714,6 +7801,16 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         }
         console.log(cyan(`telegram request from ${remoteActor}`));
         console.log(`${cyan("telegram>")} ${sanitizeTerminalText(remoteRequest.text || "")}`);
+        if (String(remoteRequest.requestKind || "").trim() === "verification") {
+          const verificationResult = await runTelegramLocalVerification(context.cwd);
+          await deliverTelegramBridgeReply(remoteRequest, {
+            sessionId: remoteSessionId,
+            content: formatTelegramVerificationSummary(verificationResult),
+            meta: { verificationResult }
+          });
+          console.log(green(`telegram verification sent -> ${remoteActor}`));
+          continue;
+        }
         const remoteManifest = await buildSelfAwarenessManifest({
           cwd: context.cwd,
           runtime: context.runtime,

package/src/gateway-state.js

@@ -53,6 +53,7 @@ function normalizeBridgeRequest(parsed = {}) {
     displayName: String(parsed?.displayName || "").trim(),
     sessionId: String(parsed?.sessionId || "").trim(),
     text: String(parsed?.text || "").trim(),
+    requestKind: String(parsed?.requestKind || "prompt").trim() || "prompt",
     explicitExecution: parsed?.explicitExecution === true,
     targetPid: Number.isFinite(Number(parsed?.targetPid)) ? Math.floor(Number(parsed.targetPid)) : 0,
     targetSessionId: String(parsed?.targetSessionId || "").trim(),
@@ -72,6 +73,7 @@ function normalizeBridgeReply(parsed = {}) {
     sessionId: String(parsed?.sessionId || "").trim(),
     content: String(parsed?.content || "").trim(),
     error: String(parsed?.error || "").trim(),
+    meta: parsed?.meta && typeof parsed.meta === "object" ? { ...parsed.meta } : {},
     completedAt: String(parsed?.completedAt || "").trim(),
     source: String(parsed?.source || "tui").trim() || "tui"
   };

package/src/gateway.js

@@ -2448,6 +2448,34 @@ class TelegramGateway {
       if (!project?.enabled) {
         return "This project is not shared.";
       }
+      const liveHosts = await this.getLiveBridgeHosts({ cwd });
+      const verifierHost = verifier ? findLiveHostForAgent(liveHosts, verifier) : null;
+      if (verifier && verifierHost?.pid) {
+        const bridgeResult = await this.runPromptViaBridge(message, sessionId, "run verification", {
+          explicitExecution: true,
+          requestKind: "verification",
+          targetHost: verifierHost,
+          includeSource: true
+        });
+        const routedResult = bridgeResult?.replyMeta?.verificationResult && typeof bridgeResult.replyMeta.verificationResult === "object"
+          ? bridgeResult.replyMeta.verificationResult
+          : null;
+        const handledBy = formatBridgeHostLabel(bridgeResult?.sourceHost || verifierHost) || verifierHost.sessionId || "live terminal";
+        if (routedResult) {
+          const nextProject = await addVerificationResult(cwd, routedResult, { actorId, actorName });
+          const latest = getLatestVerificationResult(nextProject) || routedResult;
+          return [
+            `<b>Handled by</b> <code>${escapeTelegramHtml(handledBy)}</code>`,
+            "",
+            formatVerificationResultMarkup(latest, verifier)
+          ].join("\n");
+        }
+        return [
+          `<b>Handled by</b> <code>${escapeTelegramHtml(handledBy)}</code>`,
+          "",
+          String(bridgeResult?.content || "").trim() || "<b>Verification result</b>\n(no content)"
+        ].join("\n");
+      }
       const result = await this.runLocalVerification(cwd, verifier);
       const nextProject = await addVerificationResult(cwd, result, { actorId, actorName });
       const latest = getLatestVerificationResult(nextProject) || result;
@@ -3213,6 +3241,7 @@ class TelegramGateway {
       displayName: this.describeTelegramUser(message?.from || {}).displayName,
       sessionId: String(sessionId || "").trim(),
       text: String(promptText || "").trim(),
+      requestKind: String(options.requestKind || "prompt").trim() || "prompt",
       explicitExecution: options.explicitExecution === true,
       targetPid: Number(host?.pid || 0),
       targetSessionId: String(host?.sessionId || "").trim(),
@@ -3243,7 +3272,7 @@ class TelegramGateway {
         }
         const content = String(reply.content || "").trim() || "(no content)";
         return options.includeSource
-          ? { content, sourceHost: host }
+          ? { content, sourceHost: host, replyMeta: reply.meta && typeof reply.meta === "object" ? { ...reply.meta } : {} }
           : content;
       }