arc402-cli 0.8.0 → 0.9.1

package/src/tui/index.tsx

@@ -58,14 +58,33 @@ export async function launchTUI(): Promise<void> {
     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/useCommand.ts

@@ -1,8 +1,41 @@
 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;
@@ -10,16 +43,61 @@ interface UseCommandResult {
 
 /**
  * Dispatches parsed commands to the commander program.
- * Captures stdout/stderr by monkey-patching process.stdout.write
- * and routes all output to the viewport buffer via onLine callback.
+ * 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 execute = useCallback(
-    async (input: string, onLine: (line: string) => void): Promise<void> => {
-      setIsRunning(true);
+  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", 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);
+        });
+
+        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);
+        });
+
+        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);
@@ -46,14 +124,12 @@ export function useCommand(): UseCommandResult {
             : Buffer.from(chunk).toString("utf8");
         captureBuffer += str;
         flushBuffer();
-        // call callback if provided
         const callback =
           typeof encodingOrCb === "function" ? encodingOrCb : cb;
         if (callback) callback();
         return true;
       };
 
-      // Monkey-patch (cast through unknown to bypass strict overload checking)
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (process.stdout as any).write = capturedWrite;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -100,11 +176,25 @@ export function useCommand(): UseCommandResult {
         (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 };

package/src/tui/useNotifications.ts

@@ -0,0 +1,28 @@
+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/ui/banner.ts

@@ -44,6 +44,33 @@ export function getBannerLines(config?: BannerConfig): string[] {
   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);