arc402-cli 0.7.1 → 0.7.3

package/src/commands/daemon.ts

@@ -19,7 +19,9 @@ import {
   DAEMON_SOCK,
   DAEMON_TOML,
   TEMPLATE_DAEMON_TOML,
+  loadDaemonConfig,
 } from "../daemon/config";
+import { buildNotifier } from "../daemon/notify";
 import {
   buildOpenShellSecretExports,
   buildOpenShellSshConfig,
@@ -943,6 +945,77 @@ export function registerDaemonCommands(program: Command): void {
       console.log("  5. Start the OpenShell-owned ARC-402 runtime: arc402 daemon start");
     });
 
+  // ── daemon notifications ──────────────────────────────────────────────────────
+  const notifications = daemon
+    .command("notifications")
+    .description("Show or test configured notification channels");
+
+  notifications
+    .command("show")
+    .description("Show all configured notification channels")
+    .action(() => {
+      if (!fs.existsSync(DAEMON_TOML)) {
+        console.error("daemon.toml not found. Run `arc402 daemon init` first.");
+        process.exit(1);
+      }
+      const cfg = loadDaemonConfig();
+      const notif = cfg.notifications;
+      const channels: string[] = [];
+
+      if (notif.telegram_bot_token && notif.telegram_chat_id) {
+        channels.push(`telegram  chat_id=${notif.telegram_chat_id}`);
+      }
+      if (notif.discord?.webhook_url) {
+        const u = new URL(notif.discord.webhook_url);
+        channels.push(`discord   ${u.hostname}${u.pathname.slice(0, 30)}...`);
+      }
+      if (notif.webhook?.url) {
+        channels.push(`webhook   ${notif.webhook.url}`);
+      }
+      if (notif.email?.smtp_host && notif.email?.to) {
+        channels.push(`email     ${notif.email.smtp_host}:${notif.email.smtp_port} → ${notif.email.to}`);
+      }
+
+      if (channels.length === 0) {
+        console.log("No notification channels configured.");
+        console.log("Edit ~/.arc402/daemon.toml to add Telegram, Discord, webhook, or email.");
+      } else {
+        console.log(`Configured channels (${channels.length}):`);
+        for (const ch of channels) console.log(`  ${ch}`);
+      }
+    });
+
+  notifications
+    .command("test")
+    .description("Send a test message to all configured channels")
+    .action(async () => {
+      if (!fs.existsSync(DAEMON_TOML)) {
+        console.error("daemon.toml not found. Run `arc402 daemon init` first.");
+        process.exit(1);
+      }
+      const cfg = loadDaemonConfig();
+      const notifier = buildNotifier(cfg);
+      if (!notifier.isEnabled()) {
+        console.log("No notification channels configured. Nothing to test.");
+        process.exit(0);
+      }
+      console.log("Sending test notification to all channels...");
+      try {
+        await notifier.send("daemon_started", "ARC-402 Test Notification",
+          "This is a test message from arc402 daemon notifications test."
+        );
+        console.log("Test notification sent successfully.");
+      } catch (err) {
+        console.error(`Test notification failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+    });
+
+  // Default action: show (arc402 daemon notifications → arc402 daemon notifications show)
+  notifications.action(() => {
+    notifications.help();
+  });
+
   // ── daemon channel-watch ─────────────────────────────────────────────────────
   daemon
     .command("channel-watch")

package/src/daemon/config.ts

@@ -68,6 +68,9 @@ export interface DaemonConfig {
     notify_on_channel_challenge: boolean;
     notify_on_low_balance: boolean;
     low_balance_threshold_eth: string;
+    discord: { webhook_url: string };
+    webhook: { url: string; headers: Record<string, string> };
+    email: { smtp_host: string; smtp_port: number; smtp_user: string; smtp_pass: string; to: string };
   };
   work: {
     handler: "exec" | "http" | "noop";
@@ -114,6 +117,9 @@ function withDefaults(raw: Record<string, unknown>): DaemonConfig {
   const wt = (raw.watchtower as Record<string, unknown>) ?? {};
   const p = (raw.policy as Record<string, unknown>) ?? {};
   const notif = (raw.notifications as Record<string, unknown>) ?? {};
+  const notifDiscord = (notif.discord as Record<string, unknown>) ?? {};
+  const notifWebhook = (notif.webhook as Record<string, unknown>) ?? {};
+  const notifEmail = (notif.email as Record<string, unknown>) ?? {};
   const work = (raw.work as Record<string, unknown>) ?? {};
 
   return {
@@ -169,6 +175,18 @@ function withDefaults(raw: Record<string, unknown>): DaemonConfig {
       notify_on_channel_challenge: bool(notif.notify_on_channel_challenge, true),
       notify_on_low_balance: bool(notif.notify_on_low_balance, true),
       low_balance_threshold_eth: str(notif.low_balance_threshold_eth, "0.005"),
+      discord: { webhook_url: str(notifDiscord.webhook_url) },
+      webhook: {
+        url: str(notifWebhook.url),
+        headers: (notifWebhook.headers as Record<string, string>) ?? {},
+      },
+      email: {
+        smtp_host: str(notifEmail.smtp_host),
+        smtp_port: num(notifEmail.smtp_port, 587),
+        smtp_user: str(notifEmail.smtp_user),
+        smtp_pass: str(notifEmail.smtp_pass, "env:SMTP_PASS"),
+        to: str(notifEmail.to),
+      },
     },
     work: {
       handler: (str(work.handler, "noop")) as "exec" | "http" | "noop",
@@ -213,6 +231,9 @@ export function loadDaemonConfig(configPath = DAEMON_TOML): DaemonConfig {
   // Resolve optional env: values silently (missing = disabled feature)
   config.notifications.telegram_bot_token = tryResolveEnvValue(config.notifications.telegram_bot_token);
   config.notifications.telegram_chat_id = tryResolveEnvValue(config.notifications.telegram_chat_id);
+  config.notifications.discord.webhook_url = tryResolveEnvValue(config.notifications.discord.webhook_url);
+  config.notifications.webhook.url = tryResolveEnvValue(config.notifications.webhook.url);
+  config.notifications.email.smtp_pass = tryResolveEnvValue(config.notifications.email.smtp_pass);
   config.work.http_auth_token = tryResolveEnvValue(config.work.http_auth_token);
 
   return config;
@@ -300,6 +321,20 @@ notify_on_channel_challenge = true  # Notify when watchtower submits a channel c
 notify_on_low_balance = false    # Disabled by default — enable if you want balance alerts
 low_balance_threshold_eth = "0.005"  # Balance alert threshold
 
+[notifications.discord]
+webhook_url = ""                 # Discord channel webhook URL (leave empty to disable)
+
+[notifications.webhook]
+url = ""                         # POST JSON {title, body, timestamp} to this URL (leave empty to disable)
+# headers = { Authorization = "Bearer ..." }  # Optional headers
+
+[notifications.email]
+smtp_host = ""                   # SMTP server hostname (leave empty to disable)
+smtp_port = 587
+smtp_user = ""                   # SMTP login / from address
+smtp_pass = "env:SMTP_PASS"      # Load from env, not hardcoded
+to = ""                          # Recipient address
+
 [work]
 handler = "noop"               # exec | http | noop
 exec_command = ""              # called with agreementId and spec as args (exec mode)

package/src/daemon/index.ts

@@ -27,7 +27,7 @@ import {
   type DaemonConfig,
 } from "./config";
 import { verifyWallet, getWalletBalance } from "./wallet-monitor";
-import { Notifier } from "./notify";
+import { buildNotifier } from "./notify";
 import { HireListener } from "./hire-listener";
 import { UserOpsManager, buildAcceptCalldata } from "./userops";
 import { generateReceipt, extractLearnings, createJobDirectory, cleanJobDirectory } from "./job-lifecycle";
@@ -519,19 +519,7 @@ export async function runDaemon(foreground = false): Promise<void> {
   }
 
   // ── Setup notifier ───────────────────────────────────────────────────────
-  const notifier = new Notifier(
-    config.notifications.telegram_bot_token,
-    config.notifications.telegram_chat_id,
-    {
-      hire_request: config.notifications.notify_on_hire_request,
-      hire_accepted: config.notifications.notify_on_hire_accepted,
-      hire_rejected: config.notifications.notify_on_hire_rejected,
-      delivery: config.notifications.notify_on_delivery,
-      dispute: config.notifications.notify_on_dispute,
-      channel_challenge: config.notifications.notify_on_channel_challenge,
-      low_balance: config.notifications.notify_on_low_balance,
-    }
-  );
+  const notifier = buildNotifier(config);
 
   // ── Step 10: Start relay listener ───────────────────────────────────────
   const hireListener = new HireListener(config, db, notifier, config.wallet.contract_address);

package/src/daemon/notify.ts

@@ -1,9 +1,10 @@
 /**
- * Telegram notification module for daemon events.
- * Uses Telegram Bot API — no external dependencies.
+ * Multi-channel notification module for daemon events.
+ * Supports Telegram, Discord webhooks, generic webhooks, and email (via nodemailer).
  */
 import * as https from "https";
 import * as http from "http";
+import type { DaemonConfig } from "./config";
 
 export type NotifyEvent =
   | "hire_request"
@@ -16,33 +17,36 @@ export type NotifyEvent =
   | "daemon_started"
   | "daemon_stopped";
 
-export interface TelegramConfig {
-  botToken: string;
-  chatId: string;
+// ─── Channel interface ────────────────────────────────────────────────────────
+
+export interface NotificationChannel {
+  send(title: string, body: string): Promise<void>;
 }
 
-function telegramPost(botToken: string, method: string, body: object): Promise<void> {
+// ─── HTTP helper ──────────────────────────────────────────────────────────────
+
+function httpPost(url: string, payload: string, extraHeaders: Record<string, string>): Promise<void> {
   return new Promise((resolve, reject) => {
-    const payload = JSON.stringify(body);
-    const options: https.RequestOptions = {
-      hostname: "api.telegram.org",
-      port: 443,
-      path: `/bot${botToken}/${method}`,
+    const parsed = new URL(url);
+    const mod = parsed.protocol === "https:" ? https : http;
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+      path: parsed.pathname + parsed.search,
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "Content-Length": Buffer.byteLength(payload),
+        ...extraHeaders,
       },
     };
-    const req = https.request(options, (res) => {
-      let data = "";
-      res.on("data", (c: Buffer) => { data += c.toString(); });
+    const req = mod.request(options, (res) => {
+      res.resume();
       res.on("end", () => {
-        const parsed = JSON.parse(data) as { ok: boolean; description?: string };
-        if (!parsed.ok) {
-          reject(new Error(`Telegram API error: ${parsed.description}`));
-        } else {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
           resolve();
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}`));
         }
       });
     });
@@ -52,16 +56,118 @@ function telegramPost(botToken: string, method: string, body: object): Promise<v
   });
 }
 
+// ─── Telegram channel ─────────────────────────────────────────────────────────
+
+export class TelegramChannel implements NotificationChannel {
+  constructor(private botToken: string, private chatId: string) {}
+
+  async send(title: string, body: string): Promise<void> {
+    const text = body ? `<b>${title}</b>\n${body}` : `<b>${title}</b>`;
+    const payload = JSON.stringify({ chat_id: this.chatId, text, parse_mode: "HTML" });
+    const options: https.RequestOptions = {
+      hostname: "api.telegram.org",
+      port: 443,
+      path: `/bot${this.botToken}/sendMessage`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+    };
+    await new Promise<void>((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        let data = "";
+        res.on("data", (c: Buffer) => { data += c.toString(); });
+        res.on("end", () => {
+          const parsed = JSON.parse(data) as { ok: boolean; description?: string };
+          if (!parsed.ok) {
+            reject(new Error(`Telegram API error: ${parsed.description}`));
+          } else {
+            resolve();
+          }
+        });
+      });
+      req.on("error", reject);
+      req.write(payload);
+      req.end();
+    });
+  }
+}
+
+// ─── Discord channel ──────────────────────────────────────────────────────────
+
+export class DiscordChannel implements NotificationChannel {
+  constructor(private webhookUrl: string) {}
+
+  async send(title: string, body: string): Promise<void> {
+    const content = body ? `**${title}**\n${body}` : `**${title}**`;
+    await httpPost(this.webhookUrl, JSON.stringify({ content }), {});
+  }
+}
+
+// ─── Generic webhook channel ──────────────────────────────────────────────────
+
+export class WebhookChannel implements NotificationChannel {
+  constructor(private url: string, private headers: Record<string, string> = {}) {}
+
+  async send(title: string, body: string): Promise<void> {
+    await httpPost(
+      this.url,
+      JSON.stringify({ title, body, timestamp: new Date().toISOString() }),
+      this.headers
+    );
+  }
+}
+
+// ─── Email channel (optional — requires nodemailer) ───────────────────────────
+
+export class EmailChannel implements NotificationChannel {
+  constructor(private cfg: {
+    smtpHost: string;
+    smtpPort: number;
+    smtpUser: string;
+    smtpPass: string;
+    to: string;
+  }) {}
+
+  async send(title: string, body: string): Promise<void> {
+    // nodemailer is an optional runtime dependency — load via require to skip
+    // compile-time module resolution. Throws a clear message if not installed.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+    let nodemailer: any;
+    try {
+      // Using Function constructor avoids TypeScript static import analysis.
+      nodemailer = (new Function("require", "return require('nodemailer')"))(require);
+    } catch {
+      throw new Error("nodemailer is not installed. Run: npm install nodemailer");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    const transport = nodemailer.createTransport({
+      host: this.cfg.smtpHost,
+      port: this.cfg.smtpPort,
+      auth: { user: this.cfg.smtpUser, pass: this.cfg.smtpPass },
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    await transport.sendMail({
+      from: this.cfg.smtpUser,
+      to: this.cfg.to,
+      subject: title,
+      text: body,
+    });
+  }
+}
+
+// ─── Notifier ─────────────────────────────────────────────────────────────────
+
 export class Notifier {
-  private config: TelegramConfig | null;
+  private channels: NotificationChannel[];
   private notifyFlags: Record<NotifyEvent, boolean>;
 
   constructor(
-    botToken: string,
-    chatId: string,
+    channels: NotificationChannel[],
     flags: Partial<Record<NotifyEvent, boolean>> = {}
   ) {
-    this.config = botToken && chatId ? { botToken, chatId } : null;
+    this.channels = channels;
     this.notifyFlags = {
       hire_request: flags.hire_request ?? true,
       hire_accepted: flags.hire_accepted ?? true,
@@ -76,82 +182,116 @@ export class Notifier {
   }
 
   isEnabled(): boolean {
-    return this.config !== null;
+    return this.channels.length > 0;
   }
 
-  async send(event: NotifyEvent, message: string): Promise<void> {
-    if (!this.config) return;
+  async send(event: NotifyEvent, title: string, body: string): Promise<void> {
     if (!this.notifyFlags[event]) return;
-    try {
-      await telegramPost(this.config.botToken, "sendMessage", {
-        chat_id: this.config.chatId,
-        text: message,
-        parse_mode: "HTML",
-      });
-    } catch (err) {
-      // Non-fatal — log and continue
-      process.stderr.write(`[notify] Telegram send failed: ${err}\n`);
-    }
+    await Promise.all(
+      this.channels.map(async (ch) => {
+        try {
+          await ch.send(title, body);
+        } catch (err) {
+          process.stderr.write(`[notify] Channel send failed: ${err}\n`);
+        }
+      })
+    );
   }
 
   async notifyHireRequest(hireId: string, hirerAddress: string, priceEth: string, capability: string): Promise<void> {
     const short = hirerAddress.slice(0, 10);
-    const msg = [
-      `⚡ <b>Hire Request</b>`,
-      `ID: <code>${hireId}</code>`,
-      `From: <code>${short}...</code>`,
+    await this.send("hire_request", "Hire Request", [
+      `ID: ${hireId}`,
+      `From: ${short}...`,
       `Capability: ${capability || "unspecified"}`,
       `Price: ${priceEth} ETH`,
       ``,
-      `Approve: <code>arc402 daemon approve ${hireId}</code>`,
-      `Reject:  <code>arc402 daemon reject ${hireId}</code>`,
-    ].join("\n");
-    await this.send("hire_request", msg);
+      `Approve: arc402 daemon approve ${hireId}`,
+      `Reject:  arc402 daemon reject ${hireId}`,
+    ].join("\n"));
   }
 
   async notifyHireAccepted(hireId: string, agreementId: string): Promise<void> {
-    await this.send("hire_accepted",
-      `✅ <b>Hire Accepted</b>\nID: <code>${hireId}</code>\nAgreement: <code>${agreementId}</code>`
+    await this.send("hire_accepted", "Hire Accepted",
+      `ID: ${hireId}\nAgreement: ${agreementId}`
     );
   }
 
   async notifyHireRejected(hireId: string, reason: string): Promise<void> {
-    await this.send("hire_rejected",
-      `❌ <b>Hire Rejected</b>\nID: <code>${hireId}</code>\nReason: ${reason}`
+    await this.send("hire_rejected", "Hire Rejected",
+      `ID: ${hireId}\nReason: ${reason}`
     );
   }
 
   async notifyDelivery(agreementId: string, deliveryHash: string, userOpHash: string): Promise<void> {
-    await this.send("delivery",
-      `📦 <b>Delivery Submitted</b>\nAgreement: <code>${agreementId}</code>\nDelivery hash: <code>${deliveryHash.slice(0, 16)}...</code>\nUserOp: <code>${userOpHash.slice(0, 16)}...</code>`
-    );
+    await this.send("delivery", "Delivery Submitted", [
+      `Agreement: ${agreementId}`,
+      `Delivery hash: ${deliveryHash.slice(0, 16)}...`,
+      `UserOp: ${userOpHash.slice(0, 16)}...`,
+    ].join("\n"));
   }
 
   async notifyDispute(agreementId: string, raisedBy: string): Promise<void> {
-    await this.send("dispute",
-      `⚠️ <b>Dispute Raised</b>\nAgreement: <code>${agreementId}</code>\nBy: <code>${raisedBy}</code>`
+    await this.send("dispute", "Dispute Raised",
+      `Agreement: ${agreementId}\nBy: ${raisedBy}`
     );
   }
 
   async notifyChannelChallenge(channelId: string, txHash: string): Promise<void> {
-    await this.send("channel_challenge",
-      `🔔 <b>Channel Challenged</b>\nChannel: <code>${channelId.slice(0, 16)}...</code>\nTx: <code>${txHash.slice(0, 16)}...</code>`
+    await this.send("channel_challenge", "Channel Challenged",
+      `Channel: ${channelId.slice(0, 16)}...\nTx: ${txHash.slice(0, 16)}...`
     );
   }
 
   async notifyLowBalance(balanceEth: string, thresholdEth: string): Promise<void> {
-    await this.send("low_balance",
-      `💸 <b>Low Balance Alert</b>\nCurrent: ${balanceEth} ETH\nThreshold: ${thresholdEth} ETH`
+    await this.send("low_balance", "Low Balance Alert",
+      `Current: ${balanceEth} ETH\nThreshold: ${thresholdEth} ETH`
     );
   }
 
   async notifyStarted(walletAddress: string, subsystems: string[]): Promise<void> {
-    await this.send("daemon_started",
-      `🟢 <b>ARC-402 Daemon Started</b>\nWallet: <code>${walletAddress}</code>\nSubsystems: ${subsystems.join(", ")}`
+    await this.send("daemon_started", "ARC-402 Daemon Started",
+      `Wallet: ${walletAddress}\nSubsystems: ${subsystems.join(", ")}`
     );
   }
 
   async notifyStopped(): Promise<void> {
-    await this.send("daemon_stopped", `🔴 <b>ARC-402 Daemon Stopped</b>`);
+    await this.send("daemon_stopped", "ARC-402 Daemon Stopped", "");
   }
 }
+
+// ─── Factory ──────────────────────────────────────────────────────────────────
+
+export function buildNotifier(config: DaemonConfig): Notifier {
+  const notif = config.notifications;
+  const channels: NotificationChannel[] = [];
+
+  if (notif.telegram_bot_token && notif.telegram_chat_id) {
+    channels.push(new TelegramChannel(notif.telegram_bot_token, notif.telegram_chat_id));
+  }
+  if (notif.discord?.webhook_url) {
+    channels.push(new DiscordChannel(notif.discord.webhook_url));
+  }
+  if (notif.webhook?.url) {
+    channels.push(new WebhookChannel(notif.webhook.url, notif.webhook.headers ?? {}));
+  }
+  if (notif.email?.smtp_host && notif.email?.smtp_user && notif.email?.to) {
+    channels.push(new EmailChannel({
+      smtpHost: notif.email.smtp_host,
+      smtpPort: notif.email.smtp_port,
+      smtpUser: notif.email.smtp_user,
+      smtpPass: notif.email.smtp_pass,
+      to: notif.email.to,
+    }));
+  }
+
+  return new Notifier(channels, {
+    hire_request: notif.notify_on_hire_request,
+    hire_accepted: notif.notify_on_hire_accepted,
+    hire_rejected: notif.notify_on_hire_rejected,
+    delivery: notif.notify_on_delivery,
+    dispute: notif.notify_on_dispute,
+    channel_challenge: notif.notify_on_channel_challenge,
+    low_balance: notif.notify_on_low_balance,
+  });
+}

package/src/repl.ts

@@ -231,25 +231,11 @@ class TUI {
   private setupScreen(): void {
     this.bannerLines = getBannerLines(this.bannerCfg);
 
-    write(ansi.hideCursor);
-    write(ansi.clearScreen + ansi.home);
-
-    // Banner
+    // Simple setup — print banner once, no scroll regions (breaks on macOS Terminal)
     for (const line of this.bannerLines) {
       write(line + "\n");
     }
-
-    // Separator between banner and output area
-    write(chalk.dim("─".repeat(this.termCols)) + "\n");
-
-    // Set scroll region (output area, leaves last row free for input)
-    if (this.scrollTop <= this.scrollBot) {
-      write(ansi.scrollRegion(this.scrollTop, this.scrollBot));
-    }
-
-    // Position cursor at top of output area
-    write(ansi.move(this.scrollTop, 1));
-    write(ansi.showCursor);
+    write(chalk.dim("─".repeat(Math.min(this.termCols, 60))) + "\n\n");
   }
 
   // ── Banner repaint (in-place, preserves output area) ────────────────────────
@@ -664,10 +650,11 @@ class TUI {
     if (buffer.trim()) flushLine(buffer);
   }
 
-  // ── After each command: repaint banner + input ───────────────────────────────
+  // ── After each command: show prompt ──────────────────────────────────────────
 
   private afterCommand(): void {
-    this.repaintBanner();
+    // Simple prompt — no banner repaint (causes scrollback issues on macOS Terminal)
+    write("\n");
     this.drawInputLine();
   }