arc402-cli 0.6.0 → 0.7.1

package/src/endpoint-notify.ts

@@ -5,9 +5,75 @@
  */
 import { ethers } from "ethers";
 import { AGENT_REGISTRY_ABI } from "./abis";
+import * as dns from "dns/promises";
 
 export const DEFAULT_REGISTRY_ADDRESS = "0xD5c2851B00090c92Ba7F4723FB548bb30C9B6865";
 
+// ─── SSRF protection ──────────────────────────────────────────────────────────
+
+const RFC1918_RANGES = [
+  // 10.0.0.0/8
+  (n: number) => (n >>> 24) === 10,
+  // 172.16.0.0/12
+  (n: number) => (n >>> 24) === 172 && ((n >>> 16) & 0xff) >= 16 && ((n >>> 16) & 0xff) <= 31,
+  // 192.168.0.0/16
+  (n: number) => (n >>> 24) === 192 && ((n >>> 16) & 0xff) === 168,
+];
+
+function ipToInt(ip: string): number {
+  return ip.split(".").reduce((acc, octet) => (acc << 8) | parseInt(octet, 10), 0) >>> 0;
+}
+
+function isPrivateIp(ip: string): boolean {
+  // IPv6 non-loopback — block (only allow ::1)
+  if (ip.includes(":")) {
+    return ip !== "::1";
+  }
+  const n = ipToInt(ip);
+  // Loopback 127.0.0.0/8
+  if ((n >>> 24) === 127) return true;
+  // Link-local 169.254.0.0/16 (includes AWS metadata 169.254.169.254)
+  if ((n >>> 24) === 169 && ((n >>> 16) & 0xff) === 254) return true;
+  return RFC1918_RANGES.some((fn) => fn(n));
+}
+
+/**
+ * Validates that an endpoint URL is safe to connect to (SSRF protection).
+ * Allows HTTPS (any host) and HTTP only for localhost/127.0.0.1.
+ * Blocks RFC 1918, link-local, loopback non-localhost, and AWS metadata IPs.
+ */
+export async function validateEndpointUrl(endpoint: string): Promise<void> {
+  let parsed: URL;
+  try {
+    parsed = new URL(endpoint);
+  } catch {
+    throw new Error(`Invalid endpoint URL: ${endpoint}`);
+  }
+
+  const { protocol, hostname } = parsed;
+  const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+
+  if (protocol !== "https:" && !(protocol === "http:" && isLocalhost)) {
+    throw new Error(`Endpoint must use HTTPS (or HTTP for localhost). Got: ${endpoint}`);
+  }
+
+  // Resolve hostname and check resolved IPs
+  if (!isLocalhost) {
+    let addresses: string[];
+    try {
+      addresses = await dns.resolve(hostname);
+    } catch {
+      // If DNS fails, let the fetch fail naturally; don't block
+      return;
+    }
+    for (const addr of addresses) {
+      if (isPrivateIp(addr)) {
+        throw new Error(`Endpoint resolves to a private/reserved IP (${addr}) — blocked for security`);
+      }
+    }
+  }
+}
+
 /**
  * Reads an agent's public HTTP endpoint from AgentRegistry.
  * Returns empty string if not registered or no endpoint.
@@ -25,18 +91,35 @@ 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 {
+    await validateEndpointUrl(endpoint);
+  } catch (err) {
+    console.warn(`Warning: endpoint notify blocked (${endpoint}${path}): ${err instanceof Error ? err.message : String(err)}`);
+    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

@@ -27,10 +27,12 @@ import { registerVerifyCommand } from "./commands/verify";
 import { registerContractInteractionCommands } from "./commands/contract-interaction";
 import { registerWatchtowerCommands } from "./commands/watchtower";
 import { registerColdStartCommands } from "./commands/coldstart";
+import { registerDoctorCommand } from "./commands/doctor";
 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";
 
@@ -72,10 +74,12 @@ export function createProgram(): Command {
   registerContractInteractionCommands(program);
   registerWatchtowerCommands(program);
   registerColdStartCommands(program);
+  registerDoctorCommand(program);
   registerMigrateCommands(program);
   registerFeedCommand(program);
   registerArenaCommands(program);
   registerWatchCommand(program);
+  registerBackupCommand(program);
   program.addCommand(reputation);
   program.addCommand(policy);
 

package/src/repl.ts

@@ -6,17 +6,11 @@ import { createProgram } from "./program";
 import { getBannerLines, BannerConfig } from "./ui/banner";
 import { c } from "./ui/colors";
 
-// ─── Sentinel to intercept process.exit() from commands ──────────────────────
-
-class REPLExitSignal extends Error {
-  constructor(public readonly code: number = 0) {
-    super("repl-exit-signal");
-  }
-}
-
 // ─── Config / banner helpers ──────────────────────────────────────────────────
 
 const CONFIG_PATH = path.join(os.homedir(), ".arc402", "config.json");
+const HISTORY_PATH = path.join(os.homedir(), ".arc402", "repl_history");
+const MAX_HISTORY = 1000;
 
 async function loadBannerConfig(): Promise<BannerConfig | undefined> {
   if (!fs.existsSync(CONFIG_PATH)) return undefined;
@@ -99,10 +93,21 @@ function parseTokens(input: string): string[] {
   let current = "";
   let inQuote = false;
   let quoteChar = "";
+  let escape = false;
   for (const ch of input) {
+    if (escape) {
+      current += ch;
+      escape = false;
+      continue;
+    }
     if (inQuote) {
-      if (ch === quoteChar) inQuote = false;
-      else current += ch;
+      if (quoteChar === '"' && ch === "\\") {
+        escape = true;
+      } else if (ch === quoteChar) {
+        inQuote = false;
+      } else {
+        current += ch;
+      }
     } else if (ch === '"' || ch === "'") {
       inQuote = true;
       quoteChar = ch;
@@ -174,6 +179,14 @@ class TUI {
   async start(): Promise<void> {
     this.bannerCfg = await loadBannerConfig();
 
+    // Load persisted history
+    try {
+      if (fs.existsSync(HISTORY_PATH)) {
+        const lines = fs.readFileSync(HISTORY_PATH, "utf-8").split("\n").filter(Boolean);
+        this.history = lines.slice(-MAX_HISTORY);
+      }
+    } catch { /* non-fatal */ }
+
     // Build command metadata for completion
     const template = createProgram();
     this.topCmds = template.commands.map((cmd) => cmd.name());
@@ -529,42 +542,32 @@ class TUI {
       writeErr: (str) => process.stderr.write(str),
     });
 
-    const origExit = process.exit;
-    (process as NodeJS.Process).exit = ((code?: number) => {
-      throw new REPLExitSignal(code ?? 0);
-    }) as typeof process.exit;
-
     try {
       await prog.parseAsync(["node", "arc402", ...tokens]);
     } catch (err) {
-      if (err instanceof REPLExitSignal) {
-        // Command called process.exit() — normal
+      const e = err as { code?: string; message?: string };
+      if (
+        e.code === "commander.helpDisplayed" ||
+        e.code === "commander.version" ||
+        e.code === "commander.executeSubCommandAsync"
+      ) {
+        // already written or normal exit
+      } else if (e.code === "commander.unknownCommand") {
+        process.stdout.write(
+          `\n ${c.failure} ${chalk.red(`Unknown command: ${chalk.white(tokens[0])}`)} \n`
+        );
+        process.stdout.write(
+          chalk.dim("  Type 'help' for available commands\n")
+        );
+      } else if (e.code?.startsWith("commander.")) {
+        process.stdout.write(
+          `\n ${c.failure} ${chalk.red(e.message ?? String(err))}\n`
+        );
       } else {
-        const e = err as { code?: string; message?: string };
-        if (
-          e.code === "commander.helpDisplayed" ||
-          e.code === "commander.version"
-        ) {
-          // already written
-        } else if (e.code === "commander.unknownCommand") {
-          process.stdout.write(
-            `\n ${c.failure} ${chalk.red(`Unknown command: ${chalk.white(tokens[0])}`)} \n`
-          );
-          process.stdout.write(
-            chalk.dim("  Type 'help' for available commands\n")
-          );
-        } else if (e.code?.startsWith("commander.")) {
-          process.stdout.write(
-            `\n ${c.failure} ${chalk.red(e.message ?? String(err))}\n`
-          );
-        } else {
-          process.stdout.write(
-            `\n ${c.failure} ${chalk.red(e.message ?? String(err))}\n`
-          );
-        }
+        process.stdout.write(
+          `\n ${c.failure} ${chalk.red(e.message ?? String(err))}\n`
+        );
       }
-    } finally {
-      (process as NodeJS.Process).exit = origExit;
     }
 
     // Restore raw mode + our listener (interactive commands may have toggled it)
@@ -579,7 +582,8 @@ class TUI {
 
   // ── OpenClaw chat ─────────────────────────────────────────────────────────────
 
-  private async sendChat(message: string): Promise<void> {
+  private async sendChat(rawMessage: string): Promise<void> {
+    const message = rawMessage.trim().slice(0, 10000);
     write(ansi.move(this.scrollBot, 1));
 
     let res: Response;
@@ -762,6 +766,13 @@ class TUI {
   // ── Exit ──────────────────────────────────────────────────────────────────────
 
   private exitGracefully(): void {
+    // Save history
+    try {
+      const toSave = this.history.slice(-MAX_HISTORY);
+      fs.mkdirSync(path.dirname(HISTORY_PATH), { recursive: true });
+      fs.writeFileSync(HISTORY_PATH, toSave.join("\n") + "\n", { mode: 0o600 });
+    } catch { /* non-fatal */ }
+
     write(ansi.move(this.inputRow, 1) + ansi.clearLine);
     write(" " + chalk.cyanBright("◈") + chalk.dim(" goodbye") + "\n");
     write(ansi.resetScroll);

package/src/ui/format.ts

@@ -42,6 +42,7 @@ export function formatTimeAgo(timestampSeconds: number): string {
   const now = Math.floor(Date.now() / 1000);
   const delta = now - timestampSeconds;
 
+  if (delta < 0) return "in " + formatDuration(Math.abs(delta));
   if (delta < 60) return "just now";
   if (delta < 3600) {
     const m = Math.floor(delta / 60);