@aria-cli/tools 1.0.8 → 1.0.10

package/src/executors/pty.ts

@@ -1,342 +0,0 @@
-/**
- * @aria/tools - PTY executor for interactive terminal programs
- *
- * Provides PTY (pseudo-terminal) support for running interactive programs
- * that require a terminal environment (like vim, less, etc.)
- */
-
-import * as nodePty from "node-pty";
-import { sanitizeEnv } from "./shell.js";
-
-/**
- * Options for creating a PTY session.
- */
-export interface PTYOptions {
-  /** Command to execute */
-  command: string;
-  /** Arguments to pass to the command */
-  args?: string[];
-  /** Working directory */
-  cwd?: string;
-  /** Environment variables */
-  env?: Record<string, string>;
-  /** Terminal columns (default: 80) */
-  cols?: number;
-  /** Terminal rows (default: 24) */
-  rows?: number;
-}
-
-/**
- * Result of running a command in a PTY.
- */
-export interface PTYResult {
-  /** All output from the command */
-  output: string;
-  /** Exit code of the process */
-  exitCode: number;
-}
-
-/**
- * Error thrown when a PTY operation times out.
- */
-export class PTYTimeoutError extends Error {
-  constructor(
-    message: string,
-    public readonly output: string,
-  ) {
-    super(message);
-    this.name = "PTYTimeoutError";
-  }
-}
-
-/**
- * Error thrown when a PTY operation fails.
- */
-export class PTYError extends Error {
-  constructor(
-    message: string,
-    public readonly output?: string,
-  ) {
-    super(message);
-    this.name = "PTYError";
-  }
-}
-
-/**
- * A session wrapping a PTY process.
- * Provides methods for interacting with the process and collecting output.
- */
-export class PTYSession {
-  private static MAX_OUTPUT = 10 * 1024 * 1024; // 10MB
-  private _output: string = "";
-  private _isRunning: boolean = true;
-  private _exitCode: number | undefined;
-  private _exitPromise: Promise<number>;
-  private _exitResolve!: (code: number) => void;
-  private _pty: nodePty.IPty;
-  private _dataDisposable: nodePty.IDisposable;
-  private _exitDisposable: nodePty.IDisposable;
-
-  constructor(pty: nodePty.IPty) {
-    this._pty = pty;
-
-    // Set up exit promise
-    this._exitPromise = new Promise<number>((resolve) => {
-      this._exitResolve = resolve;
-    });
-
-    // Collect output with buffer cap
-    this._dataDisposable = pty.onData((data: string) => {
-      this._output += data;
-      if (this._output.length > PTYSession.MAX_OUTPUT) {
-        this._output = this._output.slice(-PTYSession.MAX_OUTPUT);
-      }
-    });
-
-    // Handle exit
-    this._exitDisposable = pty.onExit(({ exitCode }) => {
-      this._isRunning = false;
-      this._exitCode = exitCode;
-      this._exitResolve(exitCode);
-    });
-  }
-
-  /**
-   * Write data to the terminal input.
-   */
-  write(data: string): void {
-    if (!this._isRunning) {
-      throw new PTYError("Cannot write to a closed PTY session");
-    }
-    this._pty.write(data);
-  }
-
-  /**
-   * Resize the terminal.
-   */
-  resize(cols: number, rows: number): void {
-    if (!this._isRunning) {
-      throw new PTYError("Cannot resize a closed PTY session");
-    }
-    this._pty.resize(cols, rows);
-  }
-
-  /**
-   * Wait for a pattern to appear in the output.
-   * @param pattern String or RegExp to match
-   * @param timeoutMs Timeout in milliseconds (default: 5000)
-   * @returns The output accumulated up to and including the match
-   */
-  async waitFor(pattern: string | RegExp, timeoutMs: number = 5000): Promise<string> {
-    const startTime = Date.now();
-    const regex = typeof pattern === "string" ? new RegExp(escapeRegExp(pattern)) : pattern;
-
-    // Check if pattern already matches
-    if (regex.test(this._output)) {
-      return this._output;
-    }
-
-    return new Promise<string>((resolve, reject) => {
-      let checkInterval: NodeJS.Timeout | undefined;
-      let timeoutHandle: NodeJS.Timeout | undefined;
-
-      const cleanup = () => {
-        if (checkInterval) clearInterval(checkInterval);
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-      };
-
-      const check = () => {
-        if (regex.test(this._output)) {
-          cleanup();
-          resolve(this._output);
-          return true;
-        }
-
-        if (!this._isRunning) {
-          cleanup();
-          reject(new PTYError(`Process exited before pattern was found: ${pattern}`, this._output));
-          return true;
-        }
-
-        return false;
-      };
-
-      // Initial check
-      if (check()) return;
-
-      // Set up polling
-      checkInterval = setInterval(() => {
-        check();
-      }, 10);
-
-      // Set up timeout
-      timeoutHandle = setTimeout(() => {
-        cleanup();
-        const elapsed = Date.now() - startTime;
-        reject(
-          new PTYTimeoutError(
-            `Timeout (${elapsed}ms) waiting for pattern: ${pattern}`,
-            this._output,
-          ),
-        );
-      }, timeoutMs);
-    });
-  }
-
-  /**
-   * Wait for the process to exit.
-   * @param timeoutMs Timeout in milliseconds (default: 30000)
-   * @returns The complete output
-   */
-  async waitForExit(timeoutMs: number = 30000): Promise<string> {
-    if (!this._isRunning) {
-      return this._output;
-    }
-
-    return new Promise<string>((resolve, reject) => {
-      let timeoutHandle: NodeJS.Timeout | undefined;
-
-      timeoutHandle = setTimeout(() => {
-        reject(
-          new PTYTimeoutError(`Timeout (${timeoutMs}ms) waiting for process to exit`, this._output),
-        );
-      }, timeoutMs);
-
-      this._exitPromise
-        .then(() => {
-          if (timeoutHandle) clearTimeout(timeoutHandle);
-          resolve(this._output);
-        })
-        .catch(reject);
-    });
-  }
-
-  /**
-   * Kill the process.
-   * @param signal Signal to send (default: SIGHUP on Unix)
-   */
-  kill(signal?: string): void {
-    if (!this._isRunning) {
-      return;
-    }
-
-    try {
-      this._pty.kill(signal);
-    } catch {
-      // Process may already be dead
-    }
-  }
-
-  /**
-   * Close the session and clean up resources.
-   */
-  close(): void {
-    // Kill the process first before disposing handlers
-    if (this._isRunning) {
-      this.kill("SIGKILL");
-      // Mark as not running since we won't receive the exit event
-      // after disposing the handlers
-      this._isRunning = false;
-      // Resolve the exit promise to unblock any waiters
-      // Use -1 to indicate forced termination
-      this._exitResolve(-1);
-    }
-
-    this._dataDisposable.dispose();
-    this._exitDisposable.dispose();
-  }
-
-  /**
-   * Get the current output buffer.
-   */
-  get output(): string {
-    return this._output;
-  }
-
-  /**
-   * Check if the process is still running.
-   */
-  get isRunning(): boolean {
-    return this._isRunning;
-  }
-
-  /**
-   * Get the process ID.
-   */
-  get pid(): number {
-    return this._pty.pid;
-  }
-
-  /**
-   * Get the exit code (undefined if still running).
-   */
-  get exitCode(): number | undefined {
-    return this._exitCode;
-  }
-
-  /**
-   * Get the current terminal columns.
-   */
-  get cols(): number {
-    return this._pty.cols;
-  }
-
-  /**
-   * Get the current terminal rows.
-   */
-  get rows(): number {
-    return this._pty.rows;
-  }
-}
-
-/**
- * Create a new PTY session.
- * @param options Options for the PTY
- * @returns A PTYSession wrapping the process
- */
-export async function createPTYSession(options: PTYOptions): Promise<PTYSession> {
-  const defaultCols = 80;
-  const defaultRows = 24;
-
-  const pty = nodePty.spawn(options.command, options.args ?? [], {
-    name: "xterm-256color",
-    cols: options.cols ?? defaultCols,
-    rows: options.rows ?? defaultRows,
-    cwd: options.cwd ?? process.cwd(),
-    env: {
-      ...sanitizeEnv(options.env),
-      TERM: "xterm-256color",
-    },
-  });
-
-  return new PTYSession(pty);
-}
-
-/**
- * Run a command in a PTY and wait for it to complete.
- * This is a convenience function for commands that don't require interaction.
- *
- * @param options Options for the PTY, with optional timeout
- * @returns The output and exit code
- */
-export async function runInPTY(options: PTYOptions & { timeoutMs?: number }): Promise<PTYResult> {
-  const { timeoutMs = 30000, ...ptyOptions } = options;
-  const session = await createPTYSession(ptyOptions);
-
-  try {
-    const output = await session.waitForExit(timeoutMs);
-    return {
-      output,
-      exitCode: session.exitCode ?? 0,
-    };
-  } finally {
-    session.close();
-  }
-}
-
-/**
- * Escape special regex characters in a string.
- */
-function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/executors/restart.ts

@@ -1,133 +0,0 @@
-/**
- * @aria/tools - Restart executor
- *
- * Single restart path for both TUI and daemon:
- * Register an 'exit' handler to spawn a replacement process, then SIGINT
- * the current process for graceful shutdown. The replacement starts fresh
- * and goes through normal startup (heap check, createCliContext, REPL/daemon).
- */
-
-import type { ToolContext, ToolResult } from "../types.js";
-import { success, fail } from "./utils.js";
-import { spawn } from "node:child_process";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import * as os from "node:os";
-import { RESUME_ARION_ENV, RESUME_SESSION_ENV, writeRelaunchMarker } from "@aria-cli/types";
-
-export interface RestartInput {
-  reason?: string;
-}
-
-function findPnpmWorkspaceRoot(startDir: string): string | null {
-  let dir = resolve(startDir);
-  while (true) {
-    if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-function getPnpmCommand(): string {
-  return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-}
-
-async function rebuildWorkspaceIfPresent(startDir: string): Promise<{ attempted: boolean }> {
-  const root = findPnpmWorkspaceRoot(startDir);
-  if (!root) return { attempted: false };
-
-  const pnpm = getPnpmCommand();
-  await new Promise<void>((resolvePromise, rejectPromise) => {
-    const child = spawn(pnpm, ["build"], {
-      cwd: root,
-      env: process.env,
-      stdio: "inherit",
-    });
-    child.on("error", rejectPromise);
-    child.on("close", (code) => {
-      if (code === 0) resolvePromise();
-      else rejectPromise(new Error(`pnpm build failed with exit code ${code ?? "unknown"}`));
-    });
-  });
-  return { attempted: true };
-}
-
-/**
- * Find the daemon PID for the current ARIA_HOME by scanning owner records.
- * Owner records live at $RUNTIME_ROOT/owners/*.json where RUNTIME_ROOT is
- * XDG_RUNTIME_DIR/aria or ~/.aria/run.
- */
-function findDaemonPid(): number | null {
-  const ariaHome = process.env.ARIA_HOME?.trim() || join(os.homedir(), ".aria");
-  const runtimeDir = process.env.XDG_RUNTIME_DIR?.trim();
-  const runtimeRoot = runtimeDir ? join(runtimeDir, "aria") : join(ariaHome, "run");
-  const ownersDir = join(runtimeRoot, "owners");
-
-  if (!existsSync(ownersDir)) return null;
-
-  const canonicalHome = resolve(ariaHome);
-  for (const file of readdirSync(ownersDir).filter((f) => f.endsWith(".json"))) {
-    try {
-      const record = JSON.parse(readFileSync(join(ownersDir, file), "utf8"));
-      if (record.ariaHome && resolve(record.ariaHome) === canonicalHome) {
-        return typeof record.runtimePid === "number" ? record.runtimePid : null;
-      }
-    } catch {
-      // Skip malformed records
-    }
-  }
-  return null;
-}
-
-export async function executeRestart(input: RestartInput, ctx: ToolContext): Promise<ToolResult> {
-  if (ctx.abortSignal?.aborted) return fail("Operation cancelled");
-
-  const reason = (input.reason ?? "").trim() || "Restart requested";
-
-  // Note: tool definition has requiresConfirmation: true, so the framework
-  // already prompts the user before execute() is called. No need to confirm again.
-
-  process.stderr.write(`[aria] Rebuilding workspace before restart...\n`);
-  try {
-    const rebuilt = await rebuildWorkspaceIfPresent(ctx.workingDir || process.cwd());
-    if (!rebuilt.attempted) {
-      process.stderr.write(`[aria] No pnpm workspace detected; skipping build\n`);
-    }
-  } catch (error) {
-    process.stderr.write(`[aria] Build failed; continuing restart: ${(error as Error).message}\n`);
-  }
-
-  process.stderr.write(`[aria] Restarting: ${reason}\n`);
-
-  const sessionId = process.env[RESUME_SESSION_ENV] ?? null;
-  const arionName = process.env[RESUME_ARION_ENV] || "ARIA";
-
-  // Write disk-backed marker so the replacement process can resume the session.
-  writeRelaunchMarker({
-    sessionId,
-    arionName,
-    pid: process.ppid || process.pid,
-    timestamp: new Date().toISOString(),
-  });
-
-  // Spawn replacement on exit, then SIGINT for graceful shutdown.
-  // Works for both TUI and daemon — no supervisor needed.
-  const targetPid = findDaemonPid() ?? process.pid;
-
-  process.once("exit", () => {
-    spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
-      detached: true,
-      stdio: "ignore",
-    }).unref();
-  });
-
-  process.stderr.write(`[aria] Sending SIGINT to pid ${targetPid} for graceful restart\n`);
-  try {
-    process.kill(targetPid, "SIGINT");
-  } catch {
-    process.kill(process.pid, "SIGINT");
-  }
-
-  return success("Restarting...");
-}