arc402-cli 0.7.3 → 0.7.5

package/src/tui/useCommand.ts

@@ -0,0 +1,245 @@
+import { useState, useCallback } from "react";
+import { createProgram } from "../program";
+import { spawn } from "child_process";
+import chalk from "chalk";
+import { c } from "../ui/colors";
+
+/**
+ * Commands that use interactive prompts or WalletConnect QR flows.
+ * These MUST run in a child process so they can own stdin/stdout directly,
+ * because Ink holds stdin in raw mode for its own input handling.
+ */
+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 normalized = input.trim();
+  for (const cmd of INTERACTIVE_COMMANDS) {
+    if (normalized === cmd || normalized.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.
+ *
+ * NON-INTERACTIVE commands: captures stdout/stderr by monkey-patching
+ * process.stdout.write and routes output to the viewport.
+ *
+ * INTERACTIVE commands (WalletConnect, prompts): spawns a child process
+ * running `arc402 <command>` with inherited stdin so that QR codes render
+ * and prompts accept input. Output is captured line-by-line into the viewport.
+ */
+export function useCommand(): UseCommandResult {
+  const [isRunning, setIsRunning] = useState(false);
+
+  const execute = useCallback(
+    async (input: string, onLine: (line: string) => void): Promise<void> => {
+      setIsRunning(true);
+
+      if (isInteractiveCommand(input)) {
+        await executeInteractive(input, onLine);
+      } else {
+        await executeInProcess(input, onLine);
+      }
+
+      setIsRunning(false);
+    },
+    []
+  );
+
+  return { execute, isRunning };
+}
+
+/**
+ * Run an interactive command as a child process with inherited stdin.
+ * Ink is temporarily suspended so the child can own the terminal.
+ */
+async function executeInteractive(
+  input: string,
+  onLine: (line: string) => void
+): Promise<void> {
+  const tokens = parseTokens(input);
+
+  onLine(chalk.dim("  ◈ Launching interactive session..."));
+  onLine("");
+
+  return new Promise<void>((resolve) => {
+    // Spawn arc402 as a child process with full terminal access.
+    // Use stdio: 'inherit' so the child owns stdin/stdout/stderr directly.
+    // This means its output goes straight to the terminal (not captured in viewport)
+    // but that's correct — the child needs raw terminal access for QR codes, prompts, etc.
+    const child = spawn(
+      process.execPath,
+      [process.argv[1], ...tokens],
+      {
+        stdio: "inherit",
+        env: { ...process.env, ARC402_NO_TUI: "1" }, // prevent child from launching its own TUI
+        cwd: process.cwd(),
+      }
+    );
+
+    child.on("close", (code) => {
+      onLine("");
+      if (code === 0) {
+        onLine(` ${c.success} ${chalk.dim("Command completed")}`);
+      } else {
+        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();
+    });
+  });
+}
+
+/**
+ * Run a non-interactive command in-process with captured output.
+ */
+async function executeInProcess(
+  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) => process.stdout.write(str),
+      writeErr: (str) => 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 = "";
+    }
+
+    // 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;
+  }
+}
+
+// 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/useScroll.ts

@@ -0,0 +1,65 @@
+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);
+    }
+  });
+
+  return {
+    scrollOffset,
+    setScrollOffset,
+    viewportHeight,
+    isAutoScroll,
+    scrollUp,
+    scrollDown,
+    snapToBottom,
+  };
+}

package/tsconfig.json

@@ -3,6 +3,7 @@
     "target": "ES2020",
     "module": "commonjs",
     "lib": ["ES2020"],
+    "jsx": "react-jsx",
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,
@@ -12,7 +13,11 @@
     "resolveJsonModule": true,
     "declaration": true,
     "declarationMap": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "paths": {
+      "ink": ["./node_modules/ink/build/index.d.ts"],
+      "ink-text-input": ["./node_modules/ink-text-input/build/index.d.ts"]
+    }
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]