pi-cursor-sdk 0.1.20 → 0.1.21

package/scripts/lib/cursor-child-process.d.mts

@@ -0,0 +1,10 @@
+import type { ChildProcess } from "node:child_process";
+
+export declare const DEFAULT_CHILD_SHUTDOWN_GRACE_MS: number;
+export declare function waitForChildClose(child: ChildProcess): Promise<number>;
+export declare function signalChild(child: ChildProcess, signal: NodeJS.Signals): void;
+export declare function terminateChild(
+	child: ChildProcess,
+	options?: { graceMs?: number },
+): Promise<void>;
+export declare function parseJsonLines(stdout: string): unknown[];

package/scripts/lib/cursor-child-process.mjs

@@ -0,0 +1,50 @@
+export const DEFAULT_CHILD_SHUTDOWN_GRACE_MS = 2_000;
+
+export function waitForChildClose(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(child.exitCode ?? 1);
+	return new Promise((resolve) => {
+		child.once("close", (code) => resolve(code ?? 1));
+	});
+}
+
+export function signalChild(child, signal) {
+	if (!child.pid) return;
+	try {
+		if (process.platform === "win32") {
+			child.kill(signal);
+		} else {
+			process.kill(-child.pid, signal);
+		}
+	} catch {
+		try {
+			child.kill(signal);
+		} catch {
+			// child already exited
+		}
+	}
+}
+
+export async function terminateChild(child, { graceMs = DEFAULT_CHILD_SHUTDOWN_GRACE_MS } = {}) {
+	child.stdin?.destroy?.();
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	signalChild(child, "SIGTERM");
+	const killTimer = setTimeout(() => signalChild(child, "SIGKILL"), graceMs);
+	try {
+		await waitForChildClose(child);
+	} finally {
+		clearTimeout(killTimer);
+	}
+}
+
+export function parseJsonLines(stdout) {
+	const events = [];
+	for (const line of stdout.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			events.push(JSON.parse(line));
+		} catch {
+			// ignore partial lines
+		}
+	}
+	return events;
+}

package/scripts/lib/cursor-cli-args.d.mts

@@ -0,0 +1,63 @@
+export interface CursorCliValueFlagSpec<TValue = string> {
+	[key: string]: unknown;
+	names: readonly string[];
+	takesValue?: true;
+	repeat?: boolean;
+	allowDashValue?: boolean;
+	assign?: (value: string, flagName: string) => TValue;
+}
+
+export interface CursorCliBooleanFlagSpec<TValue = boolean> {
+	[key: string]: unknown;
+	names: readonly string[];
+	takesValue: false;
+	repeat?: boolean;
+	assign?: (value: true, flagName: string) => TValue;
+}
+
+export type CursorCliFlagSpec<TValue = string> = CursorCliValueFlagSpec<TValue> | CursorCliBooleanFlagSpec<TValue>;
+
+export type CursorCliFlagSpecMap<TArgs extends Record<string, unknown>> = {
+	[K in keyof TArgs]?: CursorCliFlagSpec<unknown>;
+};
+
+export type ParsedCursorCliArgs<TDefaults extends Record<string, unknown>> = TDefaults & { help: boolean };
+
+export declare function readArgvValue(
+	argv: readonly string[],
+	index: number,
+	flagName: string,
+	fail: (message: string) => never,
+	options?: { allowDashValue?: boolean },
+): string;
+export declare function parseArgv<TDefaults extends Record<string, unknown>>(
+	argv: readonly string[],
+	options: { defaults: TDefaults; flags: CursorCliFlagSpecMap<TDefaults>; fail: (message: string) => never },
+): ParsedCursorCliArgs<TDefaults>;
+export declare function defaultSettingSourcesFromEnv(env?: NodeJS.ProcessEnv): string[] | undefined;
+export declare function defaultApiKeyFromEnv(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function readArgvApiKey(argv: readonly string[]): string | undefined;
+export declare function apiKeySecretsFromProcess(
+	argv?: readonly string[],
+	env?: NodeJS.ProcessEnv,
+): Array<string | undefined>;
+export declare function requireApiKey(
+	args: { apiKey?: string },
+	env: NodeJS.ProcessEnv,
+	fail: (message: string) => never,
+): string;
+export declare function defaultTimestampedDir(prefix: string, baseDir?: string): string;
+export declare const commonProbePathFlag: <TKey extends string>(key: TKey) => CursorCliValueFlagSpec<string>;
+export declare const commonProbeStringFlag: <TKey extends string>(key: TKey) => CursorCliValueFlagSpec<string>;
+export declare const commonBooleanFlag: (...names: string[]) => CursorCliBooleanFlagSpec<boolean>;
+export declare const commonRepeatStringFlag: (...names: string[]) => CursorCliValueFlagSpec<string>;
+export declare const commonProbeFlags: {
+	readonly cwd: CursorCliValueFlagSpec<string>;
+	readonly model: CursorCliValueFlagSpec<string>;
+	readonly prompt: CursorCliValueFlagSpec<string>;
+	readonly out: CursorCliValueFlagSpec<string>;
+	readonly sessionDir: CursorCliValueFlagSpec<string>;
+	readonly promptFile: CursorCliValueFlagSpec<string>;
+	readonly apiKey: CursorCliValueFlagSpec<string>;
+	readonly settingSources: CursorCliValueFlagSpec<string[] | undefined>;
+};

package/scripts/lib/cursor-cli-args.mjs

@@ -0,0 +1,129 @@
+import { resolve } from "node:path";
+import { CURSOR_SETTING_SOURCES_ENV, resolveCursorSettingSources } from "../../shared/cursor-setting-sources.mjs";
+
+export function readArgvValue(argv, index, flagName, fail, options = {}) {
+	const current = argv[index];
+	if (!current || (!options.allowDashValue && current.startsWith("--"))) {
+		fail(`${flagName} requires a value`);
+	}
+	return current;
+}
+
+function assignParsedArg(args, key, spec, raw, flagName) {
+	const value = spec.assign ? spec.assign(raw, flagName) : raw;
+	if (spec.repeat) {
+		args[key] = [...(Array.isArray(args[key]) ? args[key] : []), value];
+		return;
+	}
+	args[key] = value;
+}
+
+export function parseArgv(argv, { defaults, flags, fail }) {
+	const args = { ...defaults, help: false };
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		if (arg === "-h" || arg === "--help") {
+			args.help = true;
+			continue;
+		}
+
+		let matched = false;
+		for (const [key, spec] of Object.entries(flags)) {
+			for (const flagName of spec.names) {
+				if (arg === flagName) {
+					if (spec.takesValue === false) {
+						assignParsedArg(args, key, spec, true, flagName);
+					} else {
+						const raw = readArgvValue(argv, ++index, flagName, fail, { allowDashValue: spec.allowDashValue === true });
+						assignParsedArg(args, key, spec, raw, flagName);
+					}
+					matched = true;
+					break;
+				}
+				if (arg.startsWith(`${flagName}=`)) {
+					if (spec.takesValue === false) fail(`${flagName} does not accept a value`);
+					const raw = arg.slice(flagName.length + 1);
+					assignParsedArg(args, key, spec, raw, flagName);
+					matched = true;
+					break;
+				}
+			}
+			if (matched) break;
+		}
+		if (!matched) fail(`unknown argument: ${arg}`);
+	}
+	return args;
+}
+
+export function defaultSettingSourcesFromEnv(env = process.env) {
+	return resolveCursorSettingSources(env[CURSOR_SETTING_SOURCES_ENV]);
+}
+
+export function defaultApiKeyFromEnv(env = process.env) {
+	return env.CURSOR_API_KEY?.trim() || undefined;
+}
+
+export function readArgvApiKey(argv) {
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		if (arg === "--api-key") {
+			const value = argv[index + 1];
+			return typeof value === "string" ? value.trim() : undefined;
+		}
+		if (arg.startsWith("--api-key=")) return arg.slice("--api-key=".length).trim();
+	}
+	return undefined;
+}
+
+export function apiKeySecretsFromProcess(argv = process.argv.slice(2), env = process.env) {
+	return [defaultApiKeyFromEnv(env), readArgvApiKey(argv)];
+}
+
+export function requireApiKey(args, env, fail) {
+	const apiKey = args.apiKey ?? defaultApiKeyFromEnv(env);
+	if (!apiKey) {
+		fail("Cursor API key is required. Set CURSOR_API_KEY or pass --api-key.");
+	}
+	return apiKey;
+}
+
+export function defaultTimestampedDir(prefix, baseDir = "/tmp") {
+	const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+	return resolve(baseDir, `${prefix}-${stamp}`);
+}
+
+export const commonProbePathFlag = (key) => ({
+	names: [`--${key}`],
+	assign: (value) => resolve(value),
+});
+
+export const commonProbeStringFlag = (key) => ({
+	names: [`--${key}`],
+});
+
+export const commonBooleanFlag = (...names) => ({
+	names,
+	takesValue: false,
+});
+
+export const commonRepeatStringFlag = (...names) => ({
+	names,
+	repeat: true,
+});
+
+export const commonProbeFlags = {
+	cwd: commonProbePathFlag("cwd"),
+	model: commonProbeStringFlag("model"),
+	prompt: commonProbeStringFlag("prompt"),
+	out: commonProbePathFlag("out"),
+	sessionDir: { names: ["--session-dir"], assign: (value) => resolve(value) },
+	promptFile: { names: ["--prompt-file"], assign: (value) => resolve(value) },
+	apiKey: {
+		names: ["--api-key"],
+		assign: (value) => value.trim(),
+	},
+	settingSources: {
+		names: ["--setting-sources"],
+		assign: (value) => resolveCursorSettingSources(value),
+	},
+};

package/scripts/lib/cursor-script-fail.d.mts

@@ -0,0 +1 @@
+export declare function createScriptFail(prefix: string): (message: string, secrets?: string | string[]) => never;

package/scripts/lib/cursor-script-fail.mjs

@@ -0,0 +1,13 @@
+import { scrubSensitiveText } from "../../shared/cursor-sensitive-text.mjs";
+
+export function createScriptFail(prefix) {
+	return (message, secrets = []) => {
+		const secretList = Array.isArray(secrets) ? secrets : [secrets];
+		let scrubbed = scrubSensitiveText(message);
+		for (const secret of secretList) {
+			if (secret) scrubbed = scrubSensitiveText(scrubbed, secret);
+		}
+		console.error(`${prefix}: ${scrubbed}`);
+		process.exit(1);
+	};
+}

package/scripts/lib/cursor-sdk-output-filter.d.mts

@@ -0,0 +1,5 @@
+export declare const CURSOR_SDK_STARTUP_NOISE_PATTERNS: readonly string[];
+export declare function isCursorSdkOutputSuppressed(): boolean;
+export declare function suppressCursorSdkOutput<T>(operation: () => T): T;
+export declare function isCursorSdkStartupNoise(text: string): boolean;
+export declare function installCursorSdkOutputFilter(): () => void;

package/scripts/lib/cursor-smoke-env.d.mts

@@ -0,0 +1,38 @@
+export {
+	CURSOR_SDK_EVENT_DEBUG_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_ENV,
+	CURSOR_SDK_EVENT_DEBUG_ENV_NAMES,
+	CURSOR_SDK_EVENT_DEBUG_RUN_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_SESSION_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_STDERR_ENV,
+} from "../../shared/cursor-sdk-event-debug-env.mjs";
+
+export declare function sealedNodePath(nodePath?: string, envPath?: string): string;
+export declare function clearCursorSdkEventDebugEnv<TEnv extends Record<string, string | undefined>>(env: TEnv): TEnv;
+export declare function buildCursorSmokeEnv(options?: {
+	baseEnv?: Record<string, string | undefined>;
+	nodePath?: string;
+	settingSources?: string | null;
+	nativeToolDisplay?: boolean;
+	registerNativeTools?: boolean;
+	bridge?: boolean;
+	exposeBuiltinTools?: boolean;
+	term?: string;
+	eventDebugDir?: string;
+}): Record<string, string | undefined>;
+export declare function buildCursorSmokeEnvPlan(options?: {
+	baseEnv?: Record<string, string | undefined>;
+	nodePath?: string;
+	settingSources?: string | null;
+	nativeToolDisplay?: boolean;
+	registerNativeTools?: boolean;
+	bridge?: boolean;
+	exposeBuiltinTools?: boolean;
+	term?: string;
+	eventDebugDir?: string;
+}): {
+	env: Record<string, string | undefined>;
+	sealedPath: string;
+	clearEnvNames: string[];
+	envEntries: Array<[string, string]>;
+};

package/scripts/lib/cursor-smoke-env.mjs

@@ -0,0 +1,81 @@
+import { delimiter, dirname } from "node:path";
+import {
+	CURSOR_SDK_EVENT_DEBUG_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_ENV,
+	CURSOR_SDK_EVENT_DEBUG_ENV_NAMES,
+	CURSOR_SDK_EVENT_DEBUG_RUN_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_SESSION_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_STDERR_ENV,
+} from "../../shared/cursor-sdk-event-debug-env.mjs";
+
+export {
+	CURSOR_SDK_EVENT_DEBUG_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_ENV,
+	CURSOR_SDK_EVENT_DEBUG_ENV_NAMES,
+	CURSOR_SDK_EVENT_DEBUG_RUN_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_SESSION_DIR_ENV,
+	CURSOR_SDK_EVENT_DEBUG_STDERR_ENV,
+};
+
+export function sealedNodePath(nodePath = process.execPath, envPath = process.env.PATH ?? "") {
+	return [dirname(nodePath), envPath].filter(Boolean).join(delimiter);
+}
+
+export function clearCursorSdkEventDebugEnv(env) {
+	for (const name of CURSOR_SDK_EVENT_DEBUG_ENV_NAMES) delete env[name];
+	return env;
+}
+
+function boolEnv(value) {
+	return value ? "1" : "0";
+}
+
+function pushIfDefined(entries, name, value) {
+	if (value !== undefined) entries.push([name, value]);
+}
+
+export function buildCursorSmokeEnv({
+	baseEnv = process.env,
+	nodePath = process.execPath,
+	settingSources,
+	nativeToolDisplay,
+	registerNativeTools,
+	bridge,
+	exposeBuiltinTools,
+	term,
+	eventDebugDir,
+} = {}) {
+	const env = clearCursorSdkEventDebugEnv({ ...baseEnv });
+	env.PATH = sealedNodePath(nodePath, baseEnv.PATH ?? "");
+	if (settingSources === null) delete env.PI_CURSOR_SETTING_SOURCES;
+	else if (settingSources !== undefined) env.PI_CURSOR_SETTING_SOURCES = settingSources;
+	if (nativeToolDisplay !== undefined) env.PI_CURSOR_NATIVE_TOOL_DISPLAY = boolEnv(nativeToolDisplay);
+	if (registerNativeTools !== undefined) env.PI_CURSOR_REGISTER_NATIVE_TOOLS = boolEnv(registerNativeTools);
+	if (bridge !== undefined) env.PI_CURSOR_PI_TOOL_BRIDGE = boolEnv(bridge);
+	if (exposeBuiltinTools !== undefined) env.PI_CURSOR_EXPOSE_BUILTIN_TOOLS = boolEnv(exposeBuiltinTools);
+	if (term !== undefined) env.TERM = term;
+	if (eventDebugDir !== undefined) {
+		env[CURSOR_SDK_EVENT_DEBUG_ENV] = "1";
+		env[CURSOR_SDK_EVENT_DEBUG_DIR_ENV] = eventDebugDir;
+	}
+	return env;
+}
+
+export function buildCursorSmokeEnvPlan(options = {}) {
+	const env = buildCursorSmokeEnv(options);
+	const envEntries = [];
+	pushIfDefined(envEntries, "PI_CURSOR_SETTING_SOURCES", options.settingSources === null ? undefined : options.settingSources);
+	pushIfDefined(envEntries, "PI_CURSOR_NATIVE_TOOL_DISPLAY", options.nativeToolDisplay === undefined ? undefined : boolEnv(options.nativeToolDisplay));
+	pushIfDefined(envEntries, "PI_CURSOR_REGISTER_NATIVE_TOOLS", options.registerNativeTools === undefined ? undefined : boolEnv(options.registerNativeTools));
+	pushIfDefined(envEntries, "PI_CURSOR_PI_TOOL_BRIDGE", options.bridge === undefined ? undefined : boolEnv(options.bridge));
+	pushIfDefined(envEntries, "PI_CURSOR_EXPOSE_BUILTIN_TOOLS", options.exposeBuiltinTools === undefined ? undefined : boolEnv(options.exposeBuiltinTools));
+	pushIfDefined(envEntries, "TERM", options.term);
+	pushIfDefined(envEntries, CURSOR_SDK_EVENT_DEBUG_ENV, options.eventDebugDir === undefined ? undefined : "1");
+	pushIfDefined(envEntries, CURSOR_SDK_EVENT_DEBUG_DIR_ENV, options.eventDebugDir);
+	return {
+		env,
+		sealedPath: env.PATH,
+		clearEnvNames: [...CURSOR_SDK_EVENT_DEBUG_ENV_NAMES],
+		envEntries,
+	};
+}

package/scripts/lib/cursor-smoke-shell.sh

@@ -0,0 +1,174 @@
+# Shared maintainer smoke shell helpers (timeout, logging, auth seeding).
+# Source from top-level smoke scripts: . "$(dirname "$0")/lib/cursor-smoke-shell.sh"
+
+: "${SMOKE_LOG_PREFIX:=smoke}"
+SMOKE_KILL_GRACE_SECS="${SMOKE_KILL_GRACE_SECS:-2}"
+SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_NAMES=()
+SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_UNSETS=()
+
+smoke_log() {
+	printf '[%s] %s\n' "$SMOKE_LOG_PREFIX" "$*"
+}
+
+smoke_fail() {
+	printf '[%s] FAIL: %s\n' "$SMOKE_LOG_PREFIX" "$*" >&2
+	exit 1
+}
+
+smoke_require_cmd() {
+	command -v "$1" >/dev/null 2>&1 || smoke_fail "missing required command: $1"
+}
+
+smoke_resolve_cmd() {
+	local name="$1"
+	local path
+	if ! path="$(command -v -- "$name" 2>/dev/null)" || [[ -z "$path" ]]; then
+		smoke_fail "missing required command: $name"
+	fi
+	if [[ "$path" != /* ]]; then
+		smoke_fail "required command $name did not resolve to an absolute path: $path"
+	fi
+	printf '%s\n' "$path"
+}
+
+smoke_build_sealed_node_path() {
+	local node_bin="$1"
+	local base_path
+	if (( $# >= 2 )); then
+		base_path="$2"
+	else
+		base_path="$PATH"
+	fi
+	if [[ -n "$base_path" ]]; then
+		printf '%s:%s\n' "$(dirname "$node_bin")" "$base_path"
+	else
+		printf '%s\n' "$(dirname "$node_bin")"
+	fi
+}
+
+smoke_load_cursor_sdk_event_debug_env_names() {
+	local node_bin="$1"
+	local module_path="$2"
+	local name
+	SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_NAMES=()
+	while IFS= read -r name; do
+		[[ -n "$name" ]] || continue
+		SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_NAMES+=( "$name" )
+	done < <("$node_bin" --input-type=module -e 'import { pathToFileURL } from "node:url"; const mod = await import(pathToFileURL(process.argv[1]).href); for (const name of mod.CURSOR_SDK_EVENT_DEBUG_ENV_NAMES) console.log(name);' "$module_path")
+	if [[ "${#SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_NAMES[@]}" -eq 0 ]]; then
+		smoke_fail "failed to load Cursor SDK event-debug env names from $module_path"
+	fi
+}
+
+smoke_build_cursor_sdk_event_debug_unsets() {
+	local name
+	SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_UNSETS=()
+	for name in "${SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_NAMES[@]}"; do
+		SMOKE_CURSOR_SDK_EVENT_DEBUG_ENV_UNSETS+=( -u "$name" )
+	done
+}
+
+# Run a command with a wall-clock timeout. Prefer GNU/BSD timeout; fall back to a
+# process-group kill watcher with TERM then KILL (same semantics as tmux live smoke).
+smoke_run_with_timeout() {
+	local timeout_secs="$1"
+	shift
+	if command -v timeout >/dev/null 2>&1; then
+		timeout "$timeout_secs" "$@"
+		return $?
+	fi
+	if command -v gtimeout >/dev/null 2>&1; then
+		gtimeout "$timeout_secs" "$@"
+		return $?
+	fi
+
+	local restore_monitor=0
+	case $- in
+		*m*) ;;
+		*)
+			restore_monitor=1
+			set -m
+			;;
+	esac
+
+	"$@" &
+	local pid=$!
+	(
+		sleep "$timeout_secs"
+		kill -TERM "-$pid" 2>/dev/null || kill -TERM "$pid" 2>/dev/null || true
+		sleep "$SMOKE_KILL_GRACE_SECS"
+		kill -KILL "-$pid" 2>/dev/null || kill -KILL "$pid" 2>/dev/null || true
+	) &
+	local watcher=$!
+	local code=0
+	if wait "$pid"; then
+		code=0
+	else
+		code=$?
+	fi
+	kill "$watcher" 2>/dev/null || true
+	wait "$watcher" 2>/dev/null || true
+	if (( restore_monitor )); then
+		set +m
+	fi
+	return "$code"
+}
+
+# Run with timeout; map exit 124/137/143 to a smoke_fail timeout message.
+smoke_run_with_timeout_or_fail() {
+	local label="$1"
+	local timeout_secs="$2"
+	shift 2
+	smoke_log "$label (timeout ${timeout_secs}s)"
+	local restore_errexit=0
+	case $- in
+		*e*)
+			restore_errexit=1
+			set +e
+			;;
+	esac
+	local rc=0
+	smoke_run_with_timeout "$timeout_secs" "$@"
+	rc=$?
+	if (( restore_errexit )); then
+		set -e
+	fi
+	if [[ "$rc" -eq 0 ]]; then
+		return 0
+	fi
+	case "$rc" in
+		124|137|143) smoke_fail "$label timed out after ${timeout_secs}s" ;;
+		*) smoke_fail "$label exited $rc" ;;
+	esac
+}
+
+smoke_seed_pi_agent_home() {
+	local home="$1"
+	local auth_json="${2:-${AUTH_JSON:-${REAL_HOME:-$HOME}/.pi/agent/auth.json}}"
+	local models_src="${3:-${PI_AGENT_DIR:-${REAL_HOME:-$HOME}/.pi/agent}/models.json}"
+	mkdir -p "$home/.pi/agent"
+	if [[ -f "$auth_json" ]]; then
+		cp "$auth_json" "$home/.pi/agent/auth.json"
+		chmod 600 "$home/.pi/agent/auth.json"
+		smoke_log "seeded $home/.pi/agent/auth.json"
+	else
+		smoke_log "WARN: no auth.json at $auth_json"
+	fi
+	if [[ -f "$models_src" ]]; then
+		cp "$models_src" "$home/.pi/agent/models.json"
+	fi
+}
+
+smoke_has_auth_provider() {
+	local provider="$1"
+	local auth_path="$2"
+	python3 - "$provider" "$auth_path" <<'PY'
+import json, sys
+provider, path = sys.argv[1], sys.argv[2]
+try:
+    data = json.load(open(path))
+except FileNotFoundError:
+    sys.exit(1)
+sys.exit(0 if provider in data and data[provider] else 1)
+PY
+}

package/scripts/lib/cursor-visual-render.d.mts

@@ -0,0 +1,15 @@
+export declare function buildTerminalHtml(args: {
+	ansi: string;
+	plain: string;
+	options: {
+		label: string;
+		model: string;
+		mode: string;
+		cwd: string;
+		sessionId: string;
+		width: number;
+		height: number;
+		historyLines: number;
+	};
+}): string;
+export declare function writeTerminalScreenshot(htmlPath: string, pngPath: string, width: number, height: number): Promise<void>;