arc402-cli 0.7.0 → 0.7.2

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/endpoint-notify.ts

@@ -92,11 +92,13 @@ export async function resolveAgentEndpoint(
  * POSTs JSON payload to {endpoint}{path}. Returns true on success.
  * Never throws — logs a warning on failure.
  * Validates endpoint URL for SSRF before connecting.
+ * If signingKey is provided, signs the payload and adds X-ARC402-Signature / X-ARC402-Signer headers.
  */
 export async function notifyAgent(
   endpoint: string,
   path: string,
-  payload: Record<string, unknown>
+  payload: Record<string, unknown>,
+  signingKey?: string
 ): Promise<boolean> {
   if (!endpoint) return false;
   try {
@@ -106,10 +108,18 @@ export async function notifyAgent(
     return false;
   }
   try {
+    const body = JSON.stringify(payload);
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (signingKey) {
+      const wallet = new ethers.Wallet(signingKey);
+      const signature = await wallet.signMessage(body);
+      headers["X-ARC402-Signature"] = signature;
+      headers["X-ARC402-Signer"] = wallet.address;
+    }
     const res = await fetch(`${endpoint}${path}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
+      headers,
+      body,
     });
     return res.ok;
   } catch (err) {

package/src/index.ts

@@ -1,6 +1,29 @@
 #!/usr/bin/env node
 import { createProgram } from "./program";
 import { startREPL } from "./repl";
+import { configExists, loadConfig, saveConfig } from "./config";
+
+// ── Upgrade safety check ────────────────────────────────────────────────────
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const currentVersion: string = (require("../package.json") as { version: string }).version;
+
+function checkUpgrade(): void {
+  if (!configExists()) return;
+  try {
+    const config = loadConfig();
+    const prev = config.lastCliVersion;
+    if (prev && prev !== currentVersion) {
+      // Compare semver loosely — just print if different
+      console.log(`◈ Upgraded from ${prev} → ${currentVersion}`);
+    }
+    if (config.lastCliVersion !== currentVersion) {
+      // Never overwrite existing fields — only update lastCliVersion
+      saveConfig({ ...config, lastCliVersion: currentVersion });
+    }
+  } catch {
+    // Never crash on upgrade check
+  }
+}
 
 const printMode = process.argv.includes("--print");
 
@@ -11,6 +34,7 @@ if (printMode) {
   process.env["NO_COLOR"] = "1";
   process.env["FORCE_COLOR"] = "0";
   process.env["ARC402_PRINT"] = "1";
+  checkUpgrade();
   const program = createProgram();
   void program.parseAsync(process.argv).then(() => process.exit(0)).catch((e: unknown) => {
     console.error(e instanceof Error ? e.message : String(e));
@@ -18,9 +42,11 @@ if (printMode) {
   });
 } else if (process.argv.length <= 2) {
   // No subcommand — enter interactive REPL
+  checkUpgrade();
   void startREPL();
 } else {
   // One-shot mode — arc402 wallet deploy still works as usual
+  checkUpgrade();
   const program = createProgram();
   program.parse(process.argv);
 }

package/src/program.ts

@@ -32,6 +32,7 @@ import { registerMigrateCommands } from "./commands/migrate";
 import { registerFeedCommand } from "./commands/feed";
 import { registerArenaCommands } from "./commands/arena";
 import { registerWatchCommand } from "./commands/watch";
+import { registerBackupCommand } from "./commands/backup";
 import reputation from "./commands/reputation.js";
 import policy from "./commands/policy.js";
 
@@ -78,6 +79,7 @@ export function createProgram(): Command {
   registerFeedCommand(program);
   registerArenaCommands(program);
   registerWatchCommand(program);
+  registerBackupCommand(program);
   program.addCommand(reputation);
   program.addCommand(policy);