arc402-cli 0.9.19 → 0.10.0

package/src/tui/index.tsx

@@ -1,90 +0,0 @@
-import React from "react";
-import { render } from "ink";
-import { App } from "./App.js";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { createRequire } from "node:module";
-
-const pkg = createRequire(import.meta.url)("../../package.json") as { version: string };
-
-const CONFIG_PATH = path.join(os.homedir(), ".arc402", "config.json");
-
-interface Config {
-  network?: string;
-  walletContractAddress?: string;
-  rpcUrl?: string;
-}
-
-async function loadConfig(): Promise<Config> {
-  if (!fs.existsSync(CONFIG_PATH)) return {};
-  try {
-    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8")) as Config;
-  } catch {
-    return {};
-  }
-}
-
-async function getBalance(
-  rpcUrl: string,
-  address: string
-): Promise<string | undefined> {
-  try {
-    const ethersLib = await import("ethers");
-    const provider = new ethersLib.ethers.JsonRpcProvider(rpcUrl);
-    const bal = await Promise.race([
-      provider.getBalance(address),
-      new Promise<never>((_, r) =>
-        setTimeout(() => r(new Error("timeout")), 2000)
-      ),
-    ]);
-    return `${parseFloat(ethersLib.ethers.formatEther(bal)).toFixed(4)} ETH`;
-  } catch {
-    return undefined;
-  }
-}
-
-export async function launchTUI(): Promise<void> {
-  const config = await loadConfig();
-
-  let walletDisplay: string | undefined;
-  if (config.walletContractAddress) {
-    const w = config.walletContractAddress;
-    walletDisplay = `${w.slice(0, 6)}...${w.slice(-4)}`;
-  }
-
-  let balance: string | undefined;
-  if (config.rpcUrl && config.walletContractAddress) {
-    balance = await getBalance(config.rpcUrl, config.walletContractAddress);
-  }
-
-  // Enter alternate screen buffer (full-screen mode)
-  process.stdout.write("\x1b[?1049h");
-  // Hide cursor initially — Ink manages it
-  process.stdout.write("\x1b[?25l");
-
-  const restore = () => {
-    process.stdout.write("\x1b[?25h"); // show cursor
-    process.stdout.write("\x1b[?1049l"); // leave alternate buffer
-  };
-
-  // Ensure restore on unexpected exit
-  process.on("exit", restore);
-  process.on("SIGINT", restore);
-  process.on("SIGTERM", restore);
-
-  const { waitUntilExit } = render(
-    <App
-      version={pkg.version}
-      network={config.network}
-      wallet={walletDisplay}
-      balance={balance}
-    />,
-    { exitOnCtrlC: true }
-  );
-
-  await waitUntilExit();
-
-  // Clean restore
-  restore();
-}

package/src/tui/useChat.ts

@@ -1,103 +0,0 @@
-import { useState, useCallback } from "react";
-import chalk from "chalk";
-import { c } from "../ui/colors.js";
-
-interface UseChatResult {
-  send: (message: string, onLine: (line: string) => void) => Promise<void>;
-  isSending: boolean;
-}
-
-/**
- * Sends messages to the OpenClaw gateway and streams responses
- * line-by-line into the viewport buffer via onLine callback.
- */
-export function useChat(): UseChatResult {
-  const [isSending, setIsSending] = useState(false);
-
-  const send = useCallback(
-    async (message: string, onLine: (line: string) => void): Promise<void> => {
-      setIsSending(true);
-      const trimmed = message.trim().slice(0, 10000);
-
-      // Show thinking placeholder
-      onLine(chalk.dim(" ◈ ") + chalk.dim("thinking..."));
-
-      let res: Response;
-      try {
-        res = await fetch("http://localhost:19000/api/agent", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ message: trimmed, session: "arc402-tui" }),
-          signal: AbortSignal.timeout(30000),
-        });
-      } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const isDown =
-          msg.includes("ECONNREFUSED") ||
-          msg.includes("fetch failed") ||
-          msg.includes("ENOTFOUND") ||
-          msg.includes("UND_ERR_SOCKET");
-        if (isDown) {
-          onLine(
-            " " +
-              chalk.yellow("⚠") +
-              " " +
-              chalk.dim("OpenClaw gateway not running. Start with: ") +
-              chalk.white("openclaw gateway start")
-          );
-        } else {
-          onLine(` ${c.failure} ${chalk.red(msg)}`);
-        }
-        setIsSending(false);
-        return;
-      }
-
-      if (!res.body) {
-        onLine(chalk.dim(" ◈ ") + chalk.white("(empty response)"));
-        setIsSending(false);
-        return;
-      }
-
-      const flushLine = (line: string): void => {
-        // Unwrap SSE data lines
-        if (line.startsWith("data: ")) {
-          line = line.slice(6);
-          if (line === "[DONE]") return;
-          try {
-            const j = JSON.parse(line) as {
-              text?: string;
-              content?: string;
-              delta?: { text?: string };
-            };
-            line = j.text ?? j.content ?? j.delta?.text ?? line;
-          } catch {
-            /* use raw */
-          }
-        }
-        if (line.trim()) {
-          onLine(chalk.dim(" ◈ ") + chalk.white(line));
-        }
-      };
-
-      const reader = res.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) flushLine(line);
-      }
-
-      if (buffer.trim()) flushLine(buffer);
-
-      setIsSending(false);
-    },
-    []
-  );
-
-  return { send, isSending };
-}

package/src/tui/useCommand.ts

@@ -1,238 +0,0 @@
-import { useState, useCallback } from "react";
-import { spawn } from "node:child_process";
-import { createProgram } from "../program.js";
-import chalk from "chalk";
-import { c } from "../ui/colors.js";
-
-const INTERACTIVE_COMMANDS = new Set([
-  "wallet deploy",
-  "wallet set-guardian",
-  "wallet unfreeze",
-  "wallet authorize-machine-key",
-  "wallet revoke-machine-key",
-  "wallet set-passkey",
-  "wallet set-interceptor",
-  "wallet set-velocity-limit",
-  "wallet upgrade-registry",
-  "wallet execute-registry-upgrade",
-  "wallet cancel-registry-upgrade",
-  "wallet register-policy",
-  "wallet whitelist-contract",
-  "wallet governance setup",
-  "wallet policy set-limit",
-  "wallet policy set-daily-limit",
-  "wallet policy set",
-  "wallet import",
-  "config init",
-]);
-
-function isInteractiveCommand(input: string): boolean {
-  const trimmed = input.trim();
-  for (const cmd of INTERACTIVE_COMMANDS) {
-    if (trimmed === cmd || trimmed.startsWith(cmd + " ")) {
-      return true;
-    }
-  }
-  return false;
-}
-
-interface UseCommandResult {
-  execute: (input: string, onLine: (line: string) => void) => Promise<void>;
-  isRunning: boolean;
-}
-
-/**
- * Dispatches parsed commands to the commander program.
- * Interactive commands (WalletConnect, prompts) spawn a child process
- * because Ink holds stdin in raw mode.
- * Non-interactive commands run in-process with stdout monkey-patching.
- */
-export function useCommand(): UseCommandResult {
-  const [isRunning, setIsRunning] = useState(false);
-
-  const executeInteractive = useCallback(
-    (input: string, onLine: (line: string) => void): Promise<void> => {
-      return new Promise((resolve) => {
-        const tokens = parseTokens(input);
-
-        const child = spawn(process.execPath, [process.argv[1], ...tokens], {
-          stdio: ["inherit", "pipe", "pipe"],
-          env: { ...process.env, ARC402_NO_TUI: "1", ARC402_CHILD: "1", FORCE_COLOR: "1" },
-          cwd: process.cwd(),
-        });
-
-        let stdoutRemainder = "";
-        let stderrRemainder = "";
-
-        child.stdout?.on("data", (chunk: Buffer) => {
-          stdoutRemainder += chunk.toString("utf8");
-          const lines = stdoutRemainder.split("\n");
-          stdoutRemainder = lines.pop() ?? "";
-          for (const line of lines) onLine(line.replace(/\r$/, ""));
-        });
-
-        child.stderr?.on("data", (chunk: Buffer) => {
-          stderrRemainder += chunk.toString("utf8");
-          const lines = stderrRemainder.split("\n");
-          stderrRemainder = lines.pop() ?? "";
-          for (const line of lines) onLine(line.replace(/\r$/, ""));
-        });
-
-        child.on("close", (code) => {
-          if (stdoutRemainder.trim()) onLine(stdoutRemainder);
-          if (stderrRemainder.trim()) onLine(stderrRemainder);
-          if (code !== 0 && code !== null) {
-            onLine(` ${c.failure} ${chalk.red(`Command exited with code ${code}`)}`);
-          }
-          resolve();
-        });
-
-        child.on("error", (err) => {
-          onLine(` ${c.failure} ${chalk.red(`Failed to spawn: ${err.message}`)}`);
-          resolve();
-        });
-      });
-    },
-    []
-  );
-
-  const executeInProcess = useCallback(
-    async (input: string, onLine: (line: string) => void): Promise<void> => {
-      // Capture stdout/stderr
-      const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-      const originalStderrWrite = process.stderr.write.bind(process.stderr);
-
-      let captureBuffer = "";
-
-      const flushBuffer = (): void => {
-        if (!captureBuffer) return;
-        const lines = captureBuffer.split("\n");
-        captureBuffer = lines.pop() ?? "";
-        for (const line of lines) {
-          onLine(line);
-        }
-      };
-
-      const capturedWrite = (
-        chunk: string | Uint8Array,
-        encodingOrCb?: BufferEncoding | ((err?: Error | null) => void),
-        cb?: (err?: Error | null) => void
-      ): boolean => {
-        const str =
-          typeof chunk === "string"
-            ? chunk
-            : Buffer.from(chunk).toString("utf8");
-        captureBuffer += str;
-        flushBuffer();
-        const callback =
-          typeof encodingOrCb === "function" ? encodingOrCb : cb;
-        if (callback) callback();
-        return true;
-      };
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (process.stdout as any).write = capturedWrite;
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (process.stderr as any).write = capturedWrite;
-
-      try {
-        const tokens = parseTokens(input);
-        const prog = createProgram();
-        prog.exitOverride();
-        prog.configureOutput({
-          writeOut: (str: string) => process.stdout.write(str),
-          writeErr: (str: string) => process.stderr.write(str),
-        });
-
-        await prog.parseAsync(["node", "arc402", ...tokens]);
-      } catch (err) {
-        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 — no-op
-        } else if (e.code === "commander.unknownCommand") {
-          const tokens = parseTokens(input);
-          onLine(
-            ` ${c.failure} ${chalk.red(`Unknown command: ${chalk.white(tokens[0])}`)} `
-          );
-          onLine(chalk.dim("  Type 'help' for available commands"));
-        } else if (e.code?.startsWith("commander.")) {
-          onLine(` ${c.failure} ${chalk.red(e.message ?? String(err))}`);
-        } else {
-          onLine(` ${c.failure} ${chalk.red(e.message ?? String(err))}`);
-        }
-      } finally {
-        // Flush remaining buffer
-        if (captureBuffer.trim()) {
-          onLine(captureBuffer);
-          captureBuffer = "";
-        }
-
-        // Restore original write functions
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (process.stdout as any).write = originalStdoutWrite;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (process.stderr as any).write = originalStderrWrite;
-      }
-    },
-    []
-  );
-
-  const execute = useCallback(
-    async (input: string, onLine: (line: string) => void): Promise<void> => {
-      setIsRunning(true);
-      try {
-        if (isInteractiveCommand(input)) {
-          await executeInteractive(input, onLine);
-        } else {
-          await executeInProcess(input, onLine);
-        }
-      } finally {
-        setIsRunning(false);
-      }
-    },
-    [executeInteractive, executeInProcess]
-  );
-
-  return { execute, isRunning };
-}
-
-// Shell-style tokenizer
-function parseTokens(input: string): string[] {
-  const tokens: 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 (quoteChar === '"' && ch === "\\") {
-        escape = true;
-      } else if (ch === quoteChar) {
-        inQuote = false;
-      } else {
-        current += ch;
-      }
-    } else if (ch === '"' || ch === "'") {
-      inQuote = true;
-      quoteChar = ch;
-    } else if (ch === " ") {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-    } else {
-      current += ch;
-    }
-  }
-  if (current) tokens.push(current);
-  return tokens;
-}

package/src/tui/useNotifications.ts

@@ -1,28 +0,0 @@
-import { useState, useCallback } from "react";
-import type { ToastData, ToastVariant } from "./components/Toast.js";
-
-let _nextId = 0;
-
-interface UseNotificationsResult {
-  toasts: ToastData[];
-  push: (message: string, variant?: ToastVariant, duration?: number) => void;
-  dismiss: (id: string) => void;
-}
-
-export function useNotifications(): UseNotificationsResult {
-  const [toasts, setToasts] = useState<ToastData[]>([]);
-
-  const push = useCallback(
-    (message: string, variant: ToastVariant = "info", duration?: number) => {
-      const id = `toast-${++_nextId}`;
-      setToasts((prev) => [...prev, { id, message, variant, duration }]);
-    },
-    []
-  );
-
-  const dismiss = useCallback((id: string) => {
-    setToasts((prev) => prev.filter((t) => t.id !== id));
-  }, []);
-
-  return { toasts, push, dismiss };
-}

package/src/tui/useScroll.ts

@@ -1,69 +0,0 @@
-import { useState, useCallback } from "react";
-import { useInput } from "ink";
-
-interface UseScrollResult {
-  scrollOffset: number;
-  setScrollOffset: (offset: number) => void;
-  viewportHeight: number;
-  isAutoScroll: boolean;
-  scrollUp: (lines?: number) => void;
-  scrollDown: (lines?: number) => void;
-  snapToBottom: () => void;
-}
-
-/**
- * Manages scroll state for the Viewport.
- * scrollOffset=0 means auto-scroll (pinned to bottom).
- * Positive scrollOffset means scrolled up by that many lines.
- */
-export function useScroll(viewportHeight: number): UseScrollResult {
-  const [scrollOffset, setScrollOffsetState] = useState(0);
-
-  const isAutoScroll = scrollOffset === 0;
-
-  const setScrollOffset = useCallback((offset: number) => {
-    setScrollOffsetState(Math.max(0, offset));
-  }, []);
-
-  const scrollUp = useCallback(
-    (lines?: number) => {
-      const step = lines ?? viewportHeight;
-      setScrollOffsetState((prev) => prev + step);
-    },
-    [viewportHeight]
-  );
-
-  const scrollDown = useCallback(
-    (lines?: number) => {
-      const step = lines ?? viewportHeight;
-      setScrollOffsetState((prev) => Math.max(0, prev - step));
-    },
-    [viewportHeight]
-  );
-
-  const snapToBottom = useCallback(() => {
-    setScrollOffsetState(0);
-  }, []);
-
-  useInput((_input, key) => {
-    if (key.pageUp) {
-      scrollUp(viewportHeight);
-    } else if (key.pageDown) {
-      scrollDown(viewportHeight);
-    } else if (key.shift && key.upArrow) {
-      scrollUp(1);
-    } else if (key.shift && key.downArrow) {
-      scrollDown(1);
-    }
-  });
-
-  return {
-    scrollOffset,
-    setScrollOffset,
-    viewportHeight,
-    isAutoScroll,
-    scrollUp,
-    scrollDown,
-    snapToBottom,
-  };
-}

package/src/ui/banner.ts

@@ -1,78 +0,0 @@
-import { createRequire } from "node:module";
-import chalk from "chalk";
-
-const _pkg = createRequire(import.meta.url)("../../package.json") as { version: string };
-
-const ART = `
- ██████╗ ██████╗  ██████╗      ██╗  ██╗ ██████╗ ██████╗
- ██╔══██╗██╔══██╗██╔════╝      ██║  ██║██╔═══██╗╚════██╗
- ███████║██████╔╝██║     █████╗███████║██║   ██║ █████╔╝
- ██╔══██║██╔══██╗██║     ╚════╝╚════██║██║   ██║██╔═══╝
- ██║  ██║██║  ██║╚██████╗           ██║╚██████╔╝███████╗
- ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝          ╚═╝ ╚═════╝ ╚══════╝`;
-
-const SEPARATOR = chalk.cyanBright("◈") + " " + chalk.dim("─".repeat(45));
-
-export interface BannerConfig {
-  network?: string;
-  wallet?: string;
-  balance?: string;
-}
-
-/** Returns banner as an array of plain lines (no trailing newlines). */
-export function getBannerLines(config?: BannerConfig): string[] {
-  const lines: string[] = [];
-  // ART has a leading newline — skip it
-  for (const l of ART.split("\n").slice(1)) {
-    lines.push(chalk.cyan(l));
-  }
-  lines.push("");
-  lines.push(" " + chalk.dim(`agent-to-agent arcing · v${_pkg.version}`));
-  lines.push(" " + SEPARATOR);
-  if (config) {
-    lines.push("");
-    if (config.network)
-      lines.push(` ${chalk.dim("Network")}   ${chalk.white(config.network)}`);
-    if (config.wallet)
-      lines.push(` ${chalk.dim("Wallet")}    ${chalk.white(config.wallet)}`);
-    if (config.balance)
-      lines.push(` ${chalk.dim("Balance")}   ${chalk.white(config.balance)}`);
-  }
-  lines.push("");
-  lines.push(` ${chalk.dim("Type 'help' to get started")}`);
-  lines.push("");
-  return lines;
-}
-
-export interface StatusItem {
-  label: string;
-  value: string;
-}
-
-/** Returns the ASCII art lines (no status info) and a subtitle line. */
-export function getBannerArt(): { artLines: string[]; subtitle: string; separator: string } {
-  const artLines: string[] = [];
-  for (const l of ART.split("\n").slice(1)) {
-    artLines.push(chalk.cyan(l));
-  }
-  return {
-    artLines,
-    subtitle: " " + chalk.dim(`agent-to-agent arcing · v${_pkg.version}`),
-    separator: " " + SEPARATOR,
-  };
-}
-
-/** Returns structured status items for flexWrap rendering. */
-export function getStatusItems(config?: BannerConfig): StatusItem[] {
-  const items: StatusItem[] = [];
-  if (config?.network) items.push({ label: "Network", value: config.network });
-  if (config?.wallet) items.push({ label: "Wallet", value: config.wallet });
-  if (config?.balance) items.push({ label: "Balance", value: config.balance });
-  return items;
-}
-
-export function renderBanner(config?: BannerConfig): void {
-  for (const line of getBannerLines(config)) {
-    console.log(line);
-  }
-}

package/src/ui/colors.ts

@@ -1,30 +0,0 @@
-import chalk from "chalk";
-
-// ─── ARC-402 Color System ─────────────────────────────────────────────────────
-
-export const c = {
-  // Protocol mark + section headings
-  cyan: chalk.cyan,
-  brightCyan: chalk.cyanBright,
-
-  // Primary content, values
-  white: chalk.white,
-
-  // Secondary info — addresses, timestamps, labels
-  dim: chalk.dim,
-
-  // Success states, fulfilled agreements
-  green: chalk.green,
-
-  // Errors, disputes, failures
-  red: chalk.red,
-
-  // Warnings, pending states, unconfirmed
-  yellow: chalk.yellow,
-
-  // Symbols
-  mark: chalk.cyanBright("◈"),
-  success: chalk.green("✓"),
-  failure: chalk.red("✗"),
-  warning: chalk.yellow("⚠"),
-};