@moejay/wrightty 0.0.0 → 0.1.1

package/examples/record_session.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-"""record_session.py -- Start a session recording, run commands, save the asciicast file.
-
-Demonstrates Wrightty's recording capabilities:
-  - Session recording produces an asciicast v2 (.cast) file
-  - Compatible with `asciinema play` for playback and sharing
-
-Usage:
-    python examples/record_session.py
-
-Prerequisites:
-    - wrightty-server running on ws://127.0.0.1:9420
-      Start with: cargo run -p wrightty-server
-
-    - Python SDK installed (from repo root):
-      pip install -e sdks/python
-
-    - Optional: asciinema installed to play back the recording
-      pip install asciinema   or   brew install asciinema
-"""
-
-import json
-import os
-
-from wrightty import Terminal
-
-OUTPUT_PATH = "/tmp/wrightty_demo.cast"
-
-
-def main():
-    print("Spawning terminal session...")
-
-    with Terminal.spawn(cols=100, rows=30) as term:
-        info = term.get_info()
-        print(f"Connected to {info['implementation']} v{info['version']}")
-        print()
-
-        # --- Start session recording ---
-        print("Starting session recording...")
-        recording_id = term.start_session_recording(include_input=False)
-        print(f"Recording ID: {recording_id}")
-        print()
-
-        # --- Run some commands while recording ---
-        print("Running commands (these will be captured in the recording)...")
-
-        output = term.run("echo 'Hello from Wrightty!'")
-        print(f"  echo output: {output.strip()}")
-
-        output = term.run("date")
-        print(f"  date output: {output.strip()}")
-
-        output = term.run("uname -s")
-        print(f"  uname output: {output.strip()}")
-
-        output = term.run("echo 'Recording complete.'")
-        print(f"  final echo: {output.strip()}")
-        print()
-
-        # --- Stop the recording ---
-        print("Stopping recording...")
-        result = term.stop_session_recording(recording_id)
-
-        asciicast_data = result["data"]
-        duration = result.get("duration", 0)
-        event_count = result.get("events", 0)
-
-        print(f"Recorded {event_count} events over {duration:.1f}s")
-        print()
-
-        # --- Save the asciicast file ---
-        with open(OUTPUT_PATH, "w") as f:
-            f.write(asciicast_data)
-
-        file_size = os.path.getsize(OUTPUT_PATH)
-        print(f"Saved asciicast to {OUTPUT_PATH} ({file_size} bytes)")
-        print()
-
-        # Show the asciicast header so the user can inspect it
-        lines = asciicast_data.splitlines()
-        if lines:
-            header = json.loads(lines[0])
-            print("Asciicast header:")
-            print(f"  version: {header.get('version')}")
-            print(f"  width:   {header.get('width')}")
-            print(f"  height:  {header.get('height')}")
-            if "title" in header:
-                print(f"  title:   {header['title']}")
-        print()
-
-    print(f"Done. To play back the recording:")
-    print(f"  asciinema play {OUTPUT_PATH}")
-
-
-if __name__ == "__main__":
-    main()

package/install.sh

@@ -1,81 +0,0 @@
-#!/bin/sh
-# Install wrightty — terminal automation CLI
-# Usage: curl -fsSL https://raw.githubusercontent.com/moejay/wrightty/main/install.sh | sh
-set -e
-
-REPO="moejay/wrightty"
-INSTALL_DIR="${WRIGHTTY_INSTALL_DIR:-/usr/local/bin}"
-
-# Detect OS and architecture
-OS="$(uname -s)"
-ARCH="$(uname -m)"
-
-case "$OS" in
-  Linux)  OS_NAME="linux" ;;
-  Darwin) OS_NAME="macos" ;;
-  *)
-    echo "error: Unsupported OS: $OS"
-    echo "Build from source: cargo install --git https://github.com/$REPO wrightty"
-    exit 1
-    ;;
-esac
-
-case "$ARCH" in
-  x86_64|amd64)  ARCH_NAME="x86_64" ;;
-  aarch64|arm64) ARCH_NAME="aarch64" ;;
-  *)
-    echo "error: Unsupported architecture: $ARCH"
-    echo "Build from source: cargo install --git https://github.com/$REPO wrightty"
-    exit 1
-    ;;
-esac
-
-ASSET_NAME="wrightty-${OS_NAME}-${ARCH_NAME}"
-
-# Get latest release URL
-if [ -n "$WRIGHTTY_VERSION" ]; then
-  TAG="v${WRIGHTTY_VERSION}"
-  URL="https://github.com/$REPO/releases/download/$TAG/${ASSET_NAME}.tar.gz"
-else
-  URL="https://github.com/$REPO/releases/latest/download/${ASSET_NAME}.tar.gz"
-fi
-
-echo "Downloading wrightty for ${OS_NAME}/${ARCH_NAME}..."
-TMPDIR="$(mktemp -d)"
-trap 'rm -rf "$TMPDIR"' EXIT
-
-if command -v curl >/dev/null 2>&1; then
-  curl -fsSL "$URL" -o "$TMPDIR/wrightty.tar.gz"
-elif command -v wget >/dev/null 2>&1; then
-  wget -q "$URL" -O "$TMPDIR/wrightty.tar.gz"
-else
-  echo "error: curl or wget required"
-  exit 1
-fi
-
-tar xzf "$TMPDIR/wrightty.tar.gz" -C "$TMPDIR"
-
-# Install
-if [ -w "$INSTALL_DIR" ]; then
-  mv "$TMPDIR/wrightty" "$INSTALL_DIR/wrightty"
-else
-  echo "Installing to $INSTALL_DIR (requires sudo)..."
-  sudo mv "$TMPDIR/wrightty" "$INSTALL_DIR/wrightty"
-fi
-
-chmod +x "$INSTALL_DIR/wrightty"
-
-echo ""
-echo "wrightty installed to $INSTALL_DIR/wrightty"
-echo ""
-echo "Get started:"
-echo "  wrightty term --headless        # start a headless terminal server"
-echo "  wrightty run \"echo hello\"       # run a command"
-echo "  wrightty discover               # find running servers"
-echo ""
-echo "Or bridge to your terminal:"
-echo "  wrightty term --bridge-tmux     # if you use tmux"
-echo "  wrightty term --bridge-wezterm  # if you use WezTerm"
-echo "  wrightty term --bridge-kitty    # if you use Kitty"
-echo "  wrightty term --bridge-ghostty  # if you use Ghostty"
-echo "  wrightty term --bridge-zellij   # if you use Zellij"

package/sdks/node/package-lock.json

@@ -1,85 +0,0 @@
-{
-  "name": "wrightty",
-  "version": "0.1.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "wrightty",
-      "version": "0.1.0",
-      "license": "MIT",
-      "dependencies": {
-        "ws": "^8.0.0"
-      },
-      "devDependencies": {
-        "@types/ws": "^8.0.0",
-        "typescript": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/@types/node": {
-      "version": "25.5.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.5.2.tgz",
-      "integrity": "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~7.18.0"
-      }
-    },
-    "node_modules/@types/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/undici-types": {
-      "version": "7.18.2",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
-      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/ws": {
-      "version": "8.20.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
-      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    }
-  }
-}

package/sdks/node/package.json

@@ -1,44 +0,0 @@
-{
-  "name": "@moejay/wrightty",
-  "version": "0.1.0",
-  "description": "Node.js SDK for Wrightty terminal automation protocol",
-  "author": "Moe Jay",
-  "homepage": "https://github.com/moejay/wrightty",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/moejay/wrightty.git",
-    "directory": "sdks/node"
-  },
-  "bugs": {
-    "url": "https://github.com/moejay/wrightty/issues"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "terminal",
-    "automation",
-    "tui",
-    "playwright",
-    "testing",
-    "ai",
-    "agent"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "ws": "^8.0.0"
-  },
-  "devDependencies": {
-    "@types/ws": "^8.0.0",
-    "typescript": "^5.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}

package/sdks/node/src/client.ts

@@ -1,94 +0,0 @@
-/** Low-level WebSocket JSON-RPC 2.0 client for the Wrightty protocol. */
-
-import WebSocket from "ws";
-
-export class WrighttyError extends Error {
-  constructor(
-    public code: number,
-    message: string,
-  ) {
-    super(`[${code}] ${message}`);
-    this.name = "WrighttyError";
-  }
-}
-
-export class WrighttyClient {
-  private ws: WebSocket;
-  private nextId = 1;
-  private pending = new Map<
-    number,
-    {
-      resolve: (value: any) => void;
-      reject: (reason: any) => void;
-    }
-  >();
-
-  private constructor(ws: WebSocket) {
-    this.ws = ws;
-
-    ws.on("message", (data: WebSocket.Data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        const entry = this.pending.get(msg.id);
-        if (!entry) return;
-        this.pending.delete(msg.id);
-
-        if (msg.error) {
-          entry.reject(
-            new WrighttyError(msg.error.code ?? -1, msg.error.message ?? "Unknown error"),
-          );
-        } else {
-          entry.resolve(msg.result);
-        }
-      } catch {
-        // Ignore malformed messages
-      }
-    });
-
-    ws.on("close", () => {
-      for (const [id, entry] of this.pending) {
-        entry.reject(new Error("Connection closed"));
-        this.pending.delete(id);
-      }
-    });
-  }
-
-  static connect(url: string, timeoutMs = 5000): Promise<WrighttyClient> {
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(url);
-      const timer = setTimeout(() => {
-        ws.close();
-        reject(new Error(`Connection timeout after ${timeoutMs}ms: ${url}`));
-      }, timeoutMs);
-
-      ws.on("open", () => {
-        clearTimeout(timer);
-        resolve(new WrighttyClient(ws));
-      });
-
-      ws.on("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  }
-
-  async request(method: string, params: Record<string, any> = {}): Promise<any> {
-    const id = this.nextId++;
-    const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
-
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-      this.ws.send(msg, (err) => {
-        if (err) {
-          this.pending.delete(id);
-          reject(err);
-        }
-      });
-    });
-  }
-
-  close(): void {
-    this.ws.close();
-  }
-}

package/sdks/node/src/index.ts

@@ -1,19 +0,0 @@
-export { Terminal } from "./terminal";
-export { WrighttyClient, WrighttyError } from "./client";
-export type {
-  ServerInfo,
-  Capabilities,
-  ScreenshotFormat,
-  SessionInfo,
-  KeyInput,
-  KeyEvent,
-  TextMatch,
-  WaitForTextResult,
-  ScreenshotResult,
-  RecordingResult,
-  SessionRecordingData,
-  ActionRecordingData,
-  DiscoveredServer,
-  ConnectOptions,
-  SpawnOptions,
-} from "./types";

package/sdks/node/src/terminal.ts

@@ -1,258 +0,0 @@
-/** High-level Terminal API for AI agents and automation. */
-
-import { WrighttyClient } from "./client";
-import type {
-  ConnectOptions,
-  DiscoveredServer,
-  ScreenshotFormat,
-  ScreenshotResult,
-  SessionInfo,
-  SpawnOptions,
-  WaitForTextResult,
-  SessionRecordingData,
-  ActionRecordingData,
-} from "./types";
-
-const PORT_RANGE_START = 9420;
-const PORT_RANGE_END = 9520;
-
-export class Terminal {
-  private client: WrighttyClient;
-  private sessionId: string;
-  private promptPattern = /[$#>%]\s*$/;
-
-  private constructor(client: WrighttyClient, sessionId: string) {
-    this.client = client;
-    this.sessionId = sessionId;
-  }
-
-  /** Scan for running wrightty servers on ports 9420-9520. */
-  static async discover(host = "127.0.0.1"): Promise<DiscoveredServer[]> {
-    const found: DiscoveredServer[] = [];
-
-    const checks = [];
-    for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
-      const url = `ws://${host}:${port}`;
-      checks.push(
-        WrighttyClient.connect(url, 200)
-          .then(async (client) => {
-            try {
-              const info = await client.request("Wrightty.getInfo");
-              found.push({
-                url,
-                port,
-                version: info.version ?? "unknown",
-                implementation: info.implementation ?? "unknown",
-                capabilities: info.capabilities ?? {},
-              });
-            } finally {
-              client.close();
-            }
-          })
-          .catch(() => {
-            /* port not listening */
-          }),
-      );
-    }
-
-    await Promise.all(checks);
-    return found.sort((a, b) => a.port - b.port);
-  }
-
-  /** Connect to a wrightty server. Auto-discovers if no URL given. */
-  static async connect(options: ConnectOptions = {}): Promise<Terminal> {
-    let url = options.url;
-
-    if (!url) {
-      const servers = await Terminal.discover();
-      if (servers.length === 0) {
-        throw new Error(
-          "No wrightty server found. Start one with:\n" +
-            "  wrightty term --headless\n" +
-            "  wrightty term --bridge-tmux\n" +
-            "  wrightty term --bridge-wezterm",
-        );
-      }
-      url = servers[0].url;
-    }
-
-    const client = await WrighttyClient.connect(url, options.timeout ?? 5000);
-
-    let sessionId = options.sessionId;
-    if (!sessionId) {
-      const result = await client.request("Session.list");
-      const sessions: SessionInfo[] = result.sessions ?? [];
-      sessionId = sessions.length > 0 ? sessions[0].sessionId : "0";
-    }
-
-    return new Terminal(client, sessionId);
-  }
-
-  /** Connect to a headless server and create a new session. */
-  static async spawn(options: SpawnOptions = {}): Promise<Terminal> {
-    const url = options.serverUrl ?? "ws://127.0.0.1:9420";
-    const client = await WrighttyClient.connect(url);
-
-    const result = await client.request("Session.create", {
-      cols: options.cols ?? 120,
-      rows: options.rows ?? 40,
-      shell: options.shell,
-      cwd: options.cwd,
-    });
-
-    const term = new Terminal(client, result.sessionId);
-    await term.waitForPrompt(5000);
-    return term;
-  }
-
-  /** Close the connection. */
-  close(): void {
-    this.client.close();
-  }
-
-  // --- High-level API ---
-
-  /** Run a command and return its output. */
-  async run(command: string, timeoutMs = 30000): Promise<string> {
-    await this.sendText(command + "\n");
-    await this.waitForPrompt(timeoutMs);
-
-    const screen = await this.readScreen();
-    const lines = screen.trim().split("\n");
-
-    const outputLines: string[] = [];
-    let foundCmd = false;
-    for (const line of lines) {
-      if (!foundCmd) {
-        if (line.includes(command)) foundCmd = true;
-        continue;
-      }
-      if (this.promptPattern.test(line)) break;
-      outputLines.push(line);
-    }
-
-    return outputLines.join("\n");
-  }
-
-  /** Send raw text to the terminal. */
-  async sendText(text: string): Promise<void> {
-    await this.client.request("Input.sendText", {
-      sessionId: this.sessionId,
-      text,
-    });
-  }
-
-  /** Send structured keystrokes. */
-  async sendKeys(...keys: string[]): Promise<void> {
-    await this.client.request("Input.sendKeys", {
-      sessionId: this.sessionId,
-      keys,
-    });
-  }
-
-  /** Read the current visible screen as text. */
-  async readScreen(): Promise<string> {
-    const result = await this.client.request("Screen.getText", {
-      sessionId: this.sessionId,
-    });
-    return result.text;
-  }
-
-  /** Take a screenshot. */
-  async screenshot(format: ScreenshotFormat = "svg"): Promise<ScreenshotResult> {
-    return this.client.request("Screen.screenshot", {
-      sessionId: this.sessionId,
-      format,
-    });
-  }
-
-  /** Wait until a pattern appears on screen. */
-  async waitFor(pattern: string | RegExp, timeoutMs = 30000): Promise<string> {
-    const isRegex = pattern instanceof RegExp;
-    const patternStr = isRegex ? pattern.source : pattern;
-
-    const result: WaitForTextResult = await this.client.request("Screen.waitForText", {
-      sessionId: this.sessionId,
-      pattern: patternStr,
-      isRegex,
-      timeout: timeoutMs,
-      interval: 50,
-    });
-
-    if (!result.found) {
-      throw new Error(`Pattern ${patternStr} not found within ${timeoutMs}ms`);
-    }
-
-    return this.readScreen();
-  }
-
-  /** Wait for the shell prompt to appear. */
-  async waitForPrompt(timeoutMs = 10000): Promise<string> {
-    return this.waitFor(this.promptPattern, timeoutMs);
-  }
-
-  /** Override the regex used to detect the shell prompt. */
-  setPromptPattern(pattern: RegExp): void {
-    this.promptPattern = pattern;
-  }
-
-  /** Get terminal dimensions as [cols, rows]. */
-  async getSize(): Promise<[number, number]> {
-    const result = await this.client.request("Terminal.getSize", {
-      sessionId: this.sessionId,
-    });
-    return [result.cols, result.rows];
-  }
-
-  /** Resize the terminal. */
-  async resize(cols: number, rows: number): Promise<void> {
-    await this.client.request("Terminal.resize", {
-      sessionId: this.sessionId,
-      cols,
-      rows,
-    });
-  }
-
-  /** Get server info and capabilities. */
-  async getInfo(): Promise<Record<string, any>> {
-    return this.client.request("Wrightty.getInfo");
-  }
-
-  // --- Recording ---
-
-  /** Start recording raw PTY I/O (asciicast v2 format). */
-  async startSessionRecording(includeInput = false): Promise<string> {
-    const result = await this.client.request("Recording.startSession", {
-      sessionId: this.sessionId,
-      includeInput,
-    });
-    return result.recordingId;
-  }
-
-  /** Stop a session recording and return asciicast data. */
-  async stopSessionRecording(recordingId: string): Promise<SessionRecordingData> {
-    return this.client.request("Recording.stopSession", { recordingId });
-  }
-
-  /** Start recording wrightty API calls as a replayable script. */
-  async startActionRecording(format: "python" | "json" | "cli" = "python"): Promise<string> {
-    const result = await this.client.request("Recording.startActions", {
-      sessionId: this.sessionId,
-      format,
-    });
-    return result.recordingId;
-  }
-
-  /** Stop action recording and return the generated script. */
-  async stopActionRecording(recordingId: string): Promise<ActionRecordingData> {
-    return this.client.request("Recording.stopActions", { recordingId });
-  }
-
-  /** Capture a single screen frame. */
-  async captureScreen(format: ScreenshotFormat = "svg"): Promise<Record<string, any>> {
-    return this.client.request("Recording.captureScreen", {
-      sessionId: this.sessionId,
-      format,
-    });
-  }
-}