@wringer/terminal 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Geoff Whatley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,100 @@
-# Temporary Holding Version
+<div align="center">
+  <h1>@wringer/terminal</h1>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+  <p>
+    <a href="https://www.npmjs.com/package/@wringer/terminal"><img src="https://img.shields.io/npm/v/@wringer/terminal" alt="npm version"></a>
+    <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"></a>
+  </p>
+</div>
+
+The terminal driver for wringer: it runs a target's text programs in a pseudo-terminal that the run
+keeps open, sends them keys, and reads their screen.
+
+## Install
+
+```bash
+bun add @wringer/core @wringer/terminal
+```
+
+The package runs on [Bun](https://bun.sh) 1.4 or newer, which provides the pseudo-terminal.
+
+## Usage
+
+```ts
+import { createWringer, local } from '@wringer/core';
+import { terminal } from '@wringer/terminal';
+
+export const registry = createWringer({ name: 'shop' })
+  .use(terminal({ cols: 120, rows: 40 }))
+  .target('local', {
+    mode: 'attach',
+    access: 'read-write',
+    host: local(),
+    drivers: {
+      terminal: ({ run }) => ({
+        programs: {
+          tui: {
+            command: ['bun', 'src/cli.ts', 'tui'],
+            env: { SHOP_HOME: run.paths.directory },
+            cwd: '.',
+          },
+        },
+      }),
+    },
+  })
+  .build();
+```
+
+`cols` and `rows` default to 120 and 40. The target names each program an agent may start, so an
+agent never passes a command line. A program's `cwd` starts at the folder where the run's supervisor
+runs, which is the repo root, and its `env` adds to the supervisor's environment. The programs run
+on the machine where the run lives, so use the driver with a `local()` host.
+
+## Commands
+
+| Command                                     | Effect | Answer                            |
+| ------------------------------------------- | ------ | --------------------------------- |
+| `terminal start <program>`                  | write  | `{ session, pid }`                |
+| `terminal type --text <text>`               | write  | types the text as key events      |
+| `terminal type --secret-env <NAME>`         | write  | types the value of `$NAME`        |
+| `terminal press <key>...`                   | write  | presses each key in order         |
+| `terminal wait --text <t>` or `--regex <r>` | read   | `{ match: { row, col }, screen }` |
+| `terminal screen`                           | read   | `{ text, cursor, cols, rows }`    |
+| `terminal stop`                             | write  | `{ exitCode }`                    |
+| `terminal list`                             | read   | the sessions of the run           |
+
+Every command except `start` and `list` takes `--session <id>`. It is optional while one session
+runs, and required while more than one runs. Sessions are named `<program>-<n>`, such as `tui-1`.
+
+- Rows and columns count from 0. `col` counts characters of the line. A `match` counts the screen's
+  rows, and `screen.text` joins the rows a program wrapped into one line, so a secret that wrapped
+  is still redacted. Its line numbers differ from the rows after a wrap.
+- A key is a name such as `enter`, `esc`, `tab`, `up`, `f5`, `ctrl+c` or `alt+x`. The driver turns
+  it into the bytes that the program's current modes expect, so `ctrl+c` is `\x03` for a plain
+  program and `\x1b[99;5u` after the program turns on the kitty keyboard protocol. `press` refuses
+  `shift+1` and other shifted symbols, which depend on the layout: use `type --text '!'`.
+- `wait` checks the screen after each chunk of output. It fails with `check-failed` when nothing
+  matches within `--timeout-ms` (10 s by default), and keeps the last screen as evidence.
+- `screen` and a failed `wait` write `screen.txt` as evidence. The raw bytes of each session go to
+  `children/terminal-<session>.log` in the run folder, outside the evidence that a run uploads.
+
+## Secrets
+
+`type --secret-env <NAME>` reads the variable from the environment of the command, and adds its
+value to the command's secrets before it sends a key. The value is then redacted from the envelope
+and from every evidence file, including the screen.
+
+## Read-only targets
+
+A read-only target refuses `start`, `type`, `press` and `stop` with exit code 3 and the target's
+hint. `screen`, `wait` and `list` still run.
+
+## Screen engine
+
+The screen comes from [libghostty-vt](https://github.com/ghostty-org/ghostty) 1.0, compiled to WASM
+and committed as `ghostty/ghostty-vt.wasm`. `ghostty/ghostty-vt.json` records the tag, the commit,
+the Zig version and the sha256 of the file. `bun run build:ghostty` rebuilds both, and needs `zig`
+0.17.0 on the path.
+
+The WASM has no imports, so the engine cannot answer a program's queries to the terminal, such as a
+cursor position request. A program that waits for such an answer stalls.

package/dist/build-text-keys.d.ts

@@ -0,0 +1,2 @@
+import type { KeyInput } from './screen-engine.ts';
+export declare function buildTextKeys(text: string): KeyInput[];

package/dist/call-sessions.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceCaller } from '@wringer/core';
+import type { SessionArgs, SessionMethod, SessionResult } from './session-service-contract.ts';
+export declare function callSessions<Method extends SessionMethod>(sessions: ServiceCaller, method: Method, args: SessionArgs<Method>): Promise<SessionResult<Method>>;

package/dist/create-ghostty-engine.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenEngine } from './screen-engine.ts';
+export interface GhosttyEngineOptions {
+    readonly module: WebAssembly.Module;
+    readonly cols: number;
+    readonly rows: number;
+}
+export declare function createGhosttyEngine(options: GhosttyEngineOptions): ScreenEngine;

package/dist/create-raw-log.d.ts

@@ -0,0 +1,5 @@
+export interface RawLog {
+    readonly write: (bytes: Uint8Array) => void;
+    readonly close: () => Promise<void>;
+}
+export declare function createRawLog(path: string, reportError: (message: string) => void): Promise<RawLog>;

package/dist/create-terminal-session.d.ts

@@ -0,0 +1,43 @@
+import type { ScreenMatch, ScreenPattern } from './find-screen-match.ts';
+import type { ScreenEngine } from './screen-engine.ts';
+interface Screen {
+    readonly text: string;
+    readonly cursor: {
+        readonly row: number;
+        readonly col: number;
+        readonly visible: boolean;
+    };
+    readonly cols: number;
+    readonly rows: number;
+}
+interface WaitResult {
+    readonly match: ScreenMatch | null;
+    readonly screen: Screen;
+}
+export interface TerminalSession {
+    readonly id: string;
+    readonly program: string;
+    readonly pid: number;
+    readonly isRunning: () => boolean;
+    readonly readExitCode: () => number | null;
+    readonly readScreen: () => Screen;
+    readonly writeText: (text: string) => void;
+    readonly writeKeys: (names: readonly string[]) => void;
+    readonly waitForScreen: (pattern: ScreenPattern, timeoutMs: number, signal: AbortSignal) => Promise<WaitResult>;
+    readonly stop: () => Promise<number>;
+    readonly dispose: () => Promise<void>;
+}
+export interface TerminalSessionOptions {
+    readonly id: string;
+    readonly program: string;
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly cols: number;
+    readonly rows: number;
+    readonly engine: ScreenEngine;
+    readonly rawLogPath: string;
+    readonly reportError: (message: string) => void;
+}
+export declare function createTerminalSession(options: TerminalSessionOptions): Promise<TerminalSession>;
+export {};

package/dist/create-wasm-bridge.d.ts

@@ -0,0 +1,10 @@
+import type { GhosttyLayout } from './parse-ghostty-layout.ts';
+export interface WasmBridge {
+    readonly layout: GhosttyLayout;
+    readonly memory: WebAssembly.Memory;
+    readonly call: (name: string, ...args: number[]) => number;
+    readonly withScratch: <Result>(size: number, use: (pointer: number) => Result) => Result;
+    readonly expectSuccess: (result: number, what: string) => void;
+    readonly createHandle: (create: (slot: number) => number, what: string) => number;
+}
+export declare function createWasmBridge(module: WebAssembly.Module): WasmBridge;

package/dist/encode-ghostty-key.d.ts

@@ -0,0 +1,8 @@
+import type { WasmBridge } from './create-wasm-bridge.ts';
+import type { KeyInput } from './screen-engine.ts';
+export interface KeyHandles {
+    readonly encoder: number;
+    readonly keyEvent: number;
+    readonly terminal: number;
+}
+export declare function encodeGhosttyKey(bridge: WasmBridge, handles: KeyHandles, key: KeyInput): Uint8Array;

package/dist/find-screen-match.d.ts

@@ -0,0 +1,12 @@
+export type ScreenPattern = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'regex';
+    readonly source: string;
+};
+export interface ScreenMatch {
+    readonly row: number;
+    readonly col: number;
+}
+export declare function findScreenMatch(text: string, pattern: ScreenPattern): ScreenMatch | null;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { terminal } from './terminal.ts';
+export type { TerminalClient, TerminalScreen, TerminalSessionInfo, TerminalStartRequest, TerminalWaitRequest, } from './terminal.ts';
+export type { CursorState, KeyInput, KeyMods, ScreenEngine } from './screen-engine.ts';

package/dist/key-names.d.ts

@@ -0,0 +1 @@
+export declare const keyNames: Readonly<Record<string, string>>;

package/dist/parse-ghostty-layout.d.ts

@@ -0,0 +1,5 @@
+export interface GhosttyLayout {
+    readonly usizeSize: 4 | 8;
+    readonly enumValue: (enumName: string, member: string) => number;
+}
+export declare function parseGhosttyLayout(json: string): GhosttyLayout;

package/dist/parse-key.d.ts

@@ -0,0 +1,2 @@
+import type { KeyInput } from './screen-engine.ts';
+export declare function parseKey(spec: string): KeyInput | null;

package/dist/pick-session.d.ts

@@ -0,0 +1,13 @@
+export interface SessionSummary {
+    readonly id: string;
+    readonly running: boolean;
+}
+export type SessionPick = {
+    readonly kind: 'found';
+    readonly id: string;
+} | {
+    readonly kind: 'refused';
+    readonly message: string;
+    readonly hint: string;
+};
+export declare function pickSession(sessions: readonly SessionSummary[], requested: string | undefined): SessionPick;

package/dist/pick-unwrapped-text.d.ts

@@ -0,0 +1 @@
+export declare function pickUnwrappedText(wrappedText: string, logicalLines: readonly string[], totalRows: number, rows: number): string;

package/dist/pick-visible-text.d.ts

@@ -0,0 +1 @@
+export declare function pickVisibleText(text: string, totalRows: number, rows: number): string;

package/dist/read-ghostty-module.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const ghosttyWasmURL: URL;
+declare const manifestSchema: z.ZodObject<{
+    tag: z.ZodString;
+    commit: z.ZodString;
+    zig: z.ZodString;
+    optimize: z.ZodString;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export declare function readGhosttyManifest(): Promise<z.infer<typeof manifestSchema>>;
+export declare function readGhosttyModule(): Promise<WebAssembly.Module>;
+export {};

package/dist/read-ghostty-text.d.ts

@@ -0,0 +1,2 @@
+import type { WasmBridge } from './create-wasm-bridge.ts';
+export declare function readGhosttyText(bridge: WasmBridge, terminal: number, unwrap?: boolean): string;

package/dist/screen-engine.d.ts

@@ -0,0 +1,30 @@
+export interface KeyMods {
+    readonly shift: boolean;
+    readonly ctrl: boolean;
+    readonly alt: boolean;
+    readonly super: boolean;
+}
+export interface KeyInput {
+    readonly key: string;
+    readonly mods: KeyMods;
+    readonly text?: string | undefined;
+}
+export interface CursorState {
+    readonly row: number;
+    readonly col: number;
+    readonly visible: boolean;
+}
+interface ScreenSize {
+    readonly cols: number;
+    readonly rows: number;
+}
+export interface ScreenEngine {
+    readonly write: (bytes: Uint8Array) => void;
+    readonly resize: (size: ScreenSize) => void;
+    readonly text: () => string;
+    readonly unwrappedText: () => string;
+    readonly cursor: () => CursorState;
+    readonly encodeKey: (key: KeyInput) => Uint8Array;
+    readonly dispose: () => void;
+}
+export {};

package/dist/session-service-contract.d.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+export declare const screenSchema: z.ZodObject<{
+    text: z.ZodString;
+    cursor: z.ZodObject<{
+        row: z.ZodNumber;
+        col: z.ZodNumber;
+        visible: z.ZodBoolean;
+    }, z.core.$strict>;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+}, z.core.$strict>;
+export declare const sessionInfoSchema: z.ZodObject<{
+    session: z.ZodString;
+    program: z.ZodString;
+    pid: z.ZodNumber;
+    running: z.ZodBoolean;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const sessionServiceContract: {
+    start: {
+        args: z.ZodObject<{
+            program: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            session: z.ZodString;
+            pid: z.ZodNumber;
+        }, z.core.$strict>;
+    };
+    type: {
+        args: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            session: z.ZodString;
+        }, z.core.$strict>;
+    };
+    press: {
+        args: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+            keys: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            session: z.ZodString;
+        }, z.core.$strict>;
+    };
+    wait: {
+        args: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            regex: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            session: z.ZodString;
+            match: z.ZodNullable<z.ZodObject<{
+                row: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strict>>;
+            screen: z.ZodObject<{
+                text: z.ZodString;
+                cursor: z.ZodObject<{
+                    row: z.ZodNumber;
+                    col: z.ZodNumber;
+                    visible: z.ZodBoolean;
+                }, z.core.$strict>;
+                cols: z.ZodNumber;
+                rows: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    };
+    screen: {
+        args: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            session: z.ZodString;
+            screen: z.ZodObject<{
+                text: z.ZodString;
+                cursor: z.ZodObject<{
+                    row: z.ZodNumber;
+                    col: z.ZodNumber;
+                    visible: z.ZodBoolean;
+                }, z.core.$strict>;
+                cols: z.ZodNumber;
+                rows: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    };
+    stop: {
+        args: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            session: z.ZodString;
+            exitCode: z.ZodNumber;
+        }, z.core.$strict>;
+    };
+    list: {
+        args: z.ZodNull;
+        result: z.ZodObject<{
+            sessions: z.ZodArray<z.ZodObject<{
+                session: z.ZodString;
+                program: z.ZodString;
+                pid: z.ZodNumber;
+                running: z.ZodBoolean;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    };
+};
+type SessionServiceContract = typeof sessionServiceContract;
+export type SessionMethod = keyof SessionServiceContract;
+export type SessionArgs<Method extends SessionMethod> = z.output<SessionServiceContract[Method]['args']>;
+export type SessionResult<Method extends SessionMethod> = z.output<SessionServiceContract[Method]['result']>;
+export {};

package/dist/start-terminal-sessions.d.ts

@@ -0,0 +1,18 @@
+import type { ServiceInstance } from '@wringer/core';
+interface ProgramConfig {
+    readonly command: readonly string[];
+    readonly env?: Readonly<Record<string, string>> | undefined;
+    readonly cwd?: string | undefined;
+}
+export interface TerminalSessionsOptions {
+    readonly programs: Readonly<Record<string, ProgramConfig>>;
+    readonly cols: number;
+    readonly rows: number;
+    readonly module: WebAssembly.Module;
+    readonly root: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly rawLogPath: (sessionID: string) => string;
+    readonly reportError: (message: string) => void;
+}
+export declare function startTerminalSessions(options: TerminalSessionsOptions): ServiceInstance;
+export {};

package/dist/terminal.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { screenSchema, sessionInfoSchema } from './session-service-contract.ts';
+declare const startArgsSchema: z.ZodObject<{
+    program: z.ZodString;
+}, z.core.$strict>;
+declare const typeArgsSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    secretEnv: z.ZodOptional<z.ZodString>;
+    session: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const pressArgsSchema: z.ZodObject<{
+    keys: z.ZodArray<z.ZodString>;
+    session: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const waitArgsSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    regex: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    session: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const sessionArgsSchema: z.ZodObject<{
+    session: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const sessionDataSchema: z.ZodObject<{
+    session: z.ZodString;
+}, z.core.$strict>;
+declare const startDataSchema: z.ZodObject<{
+    session: z.ZodString;
+    pid: z.ZodNumber;
+}, z.core.$strict>;
+declare const pressDataSchema: z.ZodObject<{
+    session: z.ZodString;
+    keys: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const waitDataSchema: z.ZodObject<{
+    session: z.ZodString;
+    match: z.ZodObject<{
+        row: z.ZodNumber;
+        col: z.ZodNumber;
+    }, z.core.$strict>;
+    screen: z.ZodObject<{
+        text: z.ZodString;
+        cursor: z.ZodObject<{
+            row: z.ZodNumber;
+            col: z.ZodNumber;
+            visible: z.ZodBoolean;
+        }, z.core.$strict>;
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const screenDataSchema: z.ZodObject<{
+    text: z.ZodString;
+    cursor: z.ZodObject<{
+        row: z.ZodNumber;
+        col: z.ZodNumber;
+        visible: z.ZodBoolean;
+    }, z.core.$strict>;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    session: z.ZodString;
+}, z.core.$strict>;
+declare const stopDataSchema: z.ZodObject<{
+    session: z.ZodString;
+    exitCode: z.ZodNumber;
+}, z.core.$strict>;
+declare const listDataSchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        session: z.ZodString;
+        program: z.ZodString;
+        pid: z.ZodNumber;
+        running: z.ZodBoolean;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TerminalScreen = z.infer<typeof screenSchema>;
+export type TerminalSessionInfo = z.infer<typeof sessionInfoSchema>;
+export type TerminalWaitRequest = z.input<typeof waitArgsSchema>;
+export type TerminalStartRequest = z.infer<typeof startArgsSchema>;
+export interface TerminalClient {
+    readonly start: (request: TerminalStartRequest) => Promise<z.infer<typeof startDataSchema>>;
+    readonly type: (request: z.input<typeof typeArgsSchema>) => Promise<z.infer<typeof sessionDataSchema>>;
+    readonly press: (request: z.input<typeof pressArgsSchema>) => Promise<z.infer<typeof pressDataSchema>>;
+    readonly wait: (request: TerminalWaitRequest) => Promise<z.infer<typeof waitDataSchema>>;
+    readonly screen: (request?: z.input<typeof sessionArgsSchema>) => Promise<z.infer<typeof screenDataSchema>>;
+    readonly stop: (request?: z.input<typeof sessionArgsSchema>) => Promise<z.infer<typeof stopDataSchema>>;
+    readonly list: () => Promise<z.infer<typeof listDataSchema>>;
+}
+export declare const terminal: import("@wringer/core").DriverFactory<"terminal", {
+    cols?: number | undefined;
+    rows?: number | undefined;
+}, {
+    programs: Record<string, {
+        command: string[];
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }>;
+}, TerminalClient>;
+export {};

package/dist/to-session-service-methods.d.ts

@@ -0,0 +1,6 @@
+import type { ServiceMethod } from '@wringer/core';
+import type { SessionArgs, SessionMethod, SessionResult } from './session-service-contract.ts';
+export type SessionHandlers = {
+    readonly [Method in SessionMethod]: (args: SessionArgs<Method>, signal: AbortSignal) => Promise<SessionResult<Method>>;
+};
+export declare function toSessionServiceMethods(handlers: SessionHandlers): Readonly<Record<SessionMethod, ServiceMethod>>;

package/ghostty/ghostty-vt.json

@@ -0,0 +1,7 @@
+{
+  "tag": "vt-1.0.1",
+  "commit": "108cacb17ed8990840cd14abfce43d8ed8503ca1",
+  "zig": "0.17.0",
+  "optimize": "ReleaseSmall",
+  "sha256": "f937d06dfccf1793ab1c82e17d2f40e1ec154aac3d9b0f2f397453072dbec5f2"
+}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@wringer/terminal",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.0",
+  "description": "The terminal driver for wringer: drives a text program of a target's app in a pseudo-terminal and reads its screen",
+  "homepage": "https://github.com/zgeoff/wringer/tree/main/packages/terminal#readme",
+  "bugs": "https://github.com/zgeoff/wringer/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zgeoff/wringer.git",
+    "directory": "packages/terminal"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "dist",
+    "!src/test-utils",
+    "ghostty"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsrs -p tsconfig.build.json",
+    "build:ghostty": "bash scripts/build-ghostty-vt.sh",
+    "typecheck": "tsrs --noEmit"
+  },
+  "devDependencies": {
+    "@wringer/core": "0.2.0",
+    "@zgeoff/testing": "0.3.0",
+    "zod": "4.6.7"
+  },
+  "peerDependencies": {
+    "@wringer/core": "0.2.0",
+    "zod": "^4.0.0"
+  },
+  "engines": {
+    "bun": ">=1.4"
+  }
+}